@aswless_854771076/ai_short_studio_cli 0.1.0-beta.0

package/README.md

@@ -0,0 +1,56 @@
+# @vvicat/ai_short_studio_cli
+
+VVICAT 新链路无限画布的官方命令行客户端。要求 Node.js 22 或更高版本。
+
+```bash
+npm install --global @vvicat/ai_short_studio_cli
+vvicat auth login --google
+vvicat project list --json
+vvicat canvas node types --json
+```
+
+邮箱登录从 stdin 读取密码：
+
+```bash
+vvicat auth login --email user@example.com --password-stdin
+```
+
+CLI 只把 refresh token 保存到系统钥匙串，access token 仅驻留内存并在到期前自动刷新。服务地址和非敏感 profile 写入系统配置目录；可使用 `--profile`、`--base-url` 或 `VVICAT_BASE_URL` 切换环境。
+
+## 命令范围
+
+- `vvicat project`：无限画布项目增删改查。
+- `vvicat canvas get|apply`：读取或批量更新画布。
+- `vvicat canvas node`：节点类型/schema 查询、节点读写、执行。
+- `vvicat canvas edge`：连线读写。
+- `vvicat canvas asset`：资产列表、上传、版本选择和下载。
+- `vvicat task`：异步任务读取、等待和取消。
+- `vvicat config`：模型、provider、默认模型、能力默认值和并发配置。
+
+运行 `vvicat <topic> --help` 查看精确参数。所有结构化响应保持 JSON；API 错误也返回稳定的 `error.code`、`status`、`retryable` 和 `details`。
+
+退出码：`0` 成功，`3` 未认证，`4` 不存在，`5` 禁止或冲突，`6` 参数错误，`7` 其他错误。
+
+配套 Agent Skill 位于 `skills/using-vvicat-cli`，随 npm 包发布。
+
+```bash
+vvicat skill install --target codex
+vvicat skill status --target codex
+vvicat skill update --target codex
+```
+
+也可使用 `--target agents` 或 `--directory <path>`。CLI 会记录版本和 SHA-256；已安装 Skill 被用户修改后，更新默认停止，只有显式 `--force` 才覆盖。
+
+## 发布
+
+使用具有发布权限并允许 bypass 2FA 的 npm Granular Access Token：
+
+```bash
+export NODE_AUTH_TOKEN="<token>"
+npm run release:dry-run
+npm run release:test -- --version 0.1.0-beta.0
+# 加入 @vvicat organization 后发布正式包
+npm run release
+```
+
+Token 只从环境变量读取，不要放入参数、Git 或日志。

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { execute } from '@oclif/core'
+
+await execute({ dir: import.meta.url })

package/dist/auth/credential-store.d.ts

@@ -0,0 +1,6 @@
+import type { CredentialStore } from './session-manager.js';
+export declare class KeyringCredentialStore implements CredentialStore {
+    delete(profile: string): Promise<void>;
+    get(profile: string): Promise<string | null>;
+    set(profile: string, refreshToken: string): Promise<void>;
+}

package/dist/auth/credential-store.js

@@ -0,0 +1,27 @@
+import { AsyncEntry } from '@napi-rs/keyring';
+const SERVICE = 'vvicat-ai-short-studio-cli';
+export class KeyringCredentialStore {
+    async delete(profile) {
+        await new AsyncEntry(SERVICE, profile).deleteCredential().catch((error) => {
+            if (!isMissingCredential(error))
+                throw error;
+        });
+    }
+    async get(profile) {
+        try {
+            return await new AsyncEntry(SERVICE, profile).getPassword() ?? null;
+        }
+        catch (error) {
+            if (isMissingCredential(error))
+                return null;
+            throw error;
+        }
+    }
+    async set(profile, refreshToken) {
+        await new AsyncEntry(SERVICE, profile).setPassword(refreshToken);
+    }
+}
+function isMissingCredential(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : '';
+    return message.includes('no entry') || message.includes('not found') || message.includes('could not be found');
+}

package/dist/auth/google-oauth.d.ts

@@ -0,0 +1,2 @@
+import type { Session, SupabaseClient } from '@supabase/supabase-js';
+export declare function loginWithGooglePkce(client: SupabaseClient): Promise<Session>;

package/dist/auth/google-oauth.js

@@ -0,0 +1,72 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+export async function loginWithGooglePkce(client) {
+    const callback = createCallbackServer();
+    const { redirectUrl, waitForCode, close } = await callback.start();
+    try {
+        const { data, error } = await client.auth.signInWithOAuth({
+            provider: 'google',
+            options: { redirectTo: redirectUrl, skipBrowserRedirect: true },
+        });
+        if (error || !data.url)
+            throw error ?? new Error('Google 登录未返回授权地址');
+        openBrowser(data.url);
+        const code = await waitForCode();
+        const result = await client.auth.exchangeCodeForSession(code);
+        if (result.error || !result.data.session)
+            throw result.error ?? new Error('Google 登录未返回会话');
+        return result.data.session;
+    }
+    finally {
+        await close();
+    }
+}
+function createCallbackServer() {
+    const server = createServer();
+    let redirectUrl = '';
+    let resolveCode = null;
+    let rejectCode = null;
+    const codePromise = new Promise((resolve, reject) => {
+        resolveCode = resolve;
+        rejectCode = reject;
+    });
+    server.on('request', (request, response) => {
+        const url = new URL(request.url || '/', redirectUrl);
+        const code = url.searchParams.get('code');
+        const error = url.searchParams.get('error_description') || url.searchParams.get('error');
+        response.writeHead(code ? 200 : 400, { 'content-type': 'text/html; charset=utf-8' });
+        response.end(code ? '<h1>VVICAT 登录成功，可以关闭此窗口。</h1>' : '<h1>VVICAT 登录失败，请返回终端查看。</h1>');
+        if (code)
+            resolveCode?.(code);
+        else
+            rejectCode?.(new Error(error || 'Google 登录回调缺少 code'));
+    });
+    return {
+        async start() {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(0, '127.0.0.1', () => resolve());
+            });
+            const address = server.address();
+            if (!address || typeof address === 'string')
+                throw new Error('无法启动 Google 登录回调');
+            redirectUrl = `http://127.0.0.1:${address.port}/callback`;
+            return {
+                redirectUrl,
+                waitForCode: () => withTimeout(codePromise, 300_000),
+                close: () => new Promise((resolve) => server.close(() => resolve())),
+            };
+        },
+    };
+}
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(command, args, { detached: true, stdio: 'ignore' }).unref();
+}
+function withTimeout(promise, milliseconds) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Google 登录等待超时')), milliseconds);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}

package/dist/auth/session-manager.d.ts

@@ -0,0 +1,44 @@
+export interface SessionTokens {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export interface CredentialStore {
+    delete(profile: string): Promise<void>;
+    get(profile: string): Promise<string | null>;
+    set(profile: string, refreshToken: string): Promise<void>;
+}
+export interface AuthProvider {
+    login(email: string, password: string): Promise<SessionTokens>;
+    loginWithGoogle(): Promise<SessionTokens>;
+    logout(accessToken: string): Promise<void>;
+    refresh(refreshToken: string): Promise<SessionTokens>;
+}
+export declare class SupabaseAuthProvider implements AuthProvider {
+    private readonly client;
+    constructor(url: string, publishableKey: string);
+    login(email: string, password: string): Promise<SessionTokens>;
+    logout(_accessToken: string): Promise<void>;
+    loginWithGoogle(): Promise<SessionTokens>;
+    refresh(refreshToken: string): Promise<SessionTokens>;
+}
+export declare class SessionManager {
+    private current;
+    private refreshPromise;
+    private readonly credentials;
+    private readonly environment;
+    private readonly profile;
+    private readonly provider;
+    constructor(input: {
+        profile: string;
+        credentials: CredentialStore;
+        provider: AuthProvider;
+        environment?: NodeJS.ProcessEnv;
+    });
+    accessToken(): Promise<string>;
+    login(email: string, password: string): Promise<void>;
+    loginWithGoogle(): Promise<void>;
+    refreshAccessToken(): Promise<string>;
+    logout(): Promise<void>;
+    private refresh;
+}

package/dist/auth/session-manager.js

@@ -0,0 +1,100 @@
+import { createClient } from '@supabase/supabase-js';
+import { loginWithGooglePkce } from './google-oauth.js';
+export class SupabaseAuthProvider {
+    client;
+    constructor(url, publishableKey) {
+        this.client = createClient(url, publishableKey, {
+            auth: { autoRefreshToken: false, persistSession: false, flowType: 'pkce' },
+        });
+    }
+    async login(email, password) {
+        const { data, error } = await this.client.auth.signInWithPassword({ email, password });
+        if (error || !data.session)
+            throw error ?? new Error('登录响应未包含会话');
+        return sessionTokens(data.session);
+    }
+    async logout(_accessToken) {
+        const { error } = await this.client.auth.signOut();
+        if (error)
+            throw error;
+    }
+    async loginWithGoogle() {
+        return sessionTokens(await loginWithGooglePkce(this.client));
+    }
+    async refresh(refreshToken) {
+        const { data, error } = await this.client.auth.refreshSession({ refresh_token: refreshToken });
+        if (error || !data.session)
+            throw error ?? new Error('刷新响应未包含会话');
+        return sessionTokens(data.session);
+    }
+}
+function sessionTokens(session) {
+    if (!session.refresh_token || !session.expires_at)
+        throw new Error('认证会话字段不完整');
+    return {
+        accessToken: session.access_token,
+        refreshToken: session.refresh_token,
+        expiresAt: session.expires_at * 1000,
+    };
+}
+export class SessionManager {
+    current = null;
+    refreshPromise = null;
+    credentials;
+    environment;
+    profile;
+    provider;
+    constructor(input) {
+        this.profile = input.profile;
+        this.credentials = input.credentials;
+        this.provider = input.provider;
+        this.environment = input.environment ?? process.env;
+    }
+    async accessToken() {
+        if (this.environment.VVICAT_ACCESS_TOKEN)
+            return this.environment.VVICAT_ACCESS_TOKEN;
+        if (this.current && this.current.expiresAt > Date.now() + 60_000)
+            return this.current.accessToken;
+        if (!this.refreshPromise) {
+            this.refreshPromise = this.refresh().finally(() => {
+                this.refreshPromise = null;
+            });
+        }
+        return this.refreshPromise;
+    }
+    async login(email, password) {
+        this.current = await this.provider.login(email, password);
+        await this.credentials.set(this.profile, this.current.refreshToken);
+    }
+    async loginWithGoogle() {
+        this.current = await this.provider.loginWithGoogle();
+        await this.credentials.set(this.profile, this.current.refreshToken);
+    }
+    async refreshAccessToken() {
+        if (this.environment.VVICAT_ACCESS_TOKEN)
+            return this.environment.VVICAT_ACCESS_TOKEN;
+        if (!this.refreshPromise) {
+            this.refreshPromise = this.refresh().finally(() => {
+                this.refreshPromise = null;
+            });
+        }
+        return this.refreshPromise;
+    }
+    async logout() {
+        if (!this.environment.VVICAT_ACCESS_TOKEN) {
+            const accessToken = await this.accessToken().catch(() => null);
+            if (accessToken)
+                await this.provider.logout(accessToken);
+            await this.credentials.delete(this.profile);
+        }
+        this.current = null;
+    }
+    async refresh() {
+        const refreshToken = await this.credentials.get(this.profile);
+        if (!refreshToken)
+            throw new Error('尚未登录，请先运行 vvicat auth login');
+        this.current = await this.provider.refresh(refreshToken);
+        await this.credentials.set(this.profile, this.current.refreshToken);
+        return this.current.accessToken;
+    }
+}

package/dist/base-command.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        locale: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected print(value: unknown): void;
+    catch(error: unknown): Promise<void>;
+}

package/dist/base-command.js

@@ -0,0 +1,39 @@
+import { Command, Flags } from '@oclif/core';
+import { CliApiError } from './client/errors.js';
+import { formatJson } from './output/formatter.js';
+export class BaseCommand extends Command {
+    static baseFlags = {
+        'base-url': Flags.string({ description: 'VVICAT 服务地址', env: 'VVICAT_BASE_URL' }),
+        json: Flags.boolean({ description: '输出稳定 JSON', default: false }),
+        locale: Flags.string({ description: '响应语言', default: 'zh', options: ['zh', 'en'] }),
+        profile: Flags.string({ description: '配置档案名称' }),
+    };
+    print(value) {
+        this.log(formatJson(value));
+    }
+    async catch(error) {
+        if (error instanceof CliApiError) {
+            this.error(formatJson({
+                error: {
+                    code: error.code,
+                    message: error.message,
+                    retryable: error.retryable,
+                    status: error.status,
+                    details: error.details,
+                },
+            }), { exit: exitCode(error.status) });
+        }
+        this.error(error instanceof Error ? error.message : String(error), { exit: 7 });
+    }
+}
+function exitCode(status) {
+    if (status === 401)
+        return 3;
+    if (status === 403 || status === 409)
+        return 5;
+    if (status === 404)
+        return 4;
+    if (status === 400 || status === 422)
+        return 6;
+    return 7;
+}

package/dist/client/api-client.d.ts

@@ -0,0 +1,23 @@
+export interface ApiSession {
+    accessToken(): Promise<string>;
+    refreshAccessToken(): Promise<string>;
+}
+export interface ApiRequestOptions extends Omit<RequestInit, 'body'> {
+    auth?: boolean;
+    body?: unknown;
+}
+export declare class ApiClient {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly locale;
+    private readonly session;
+    constructor(input: {
+        baseUrl: string;
+        session: ApiSession;
+        fetcher?: typeof fetch;
+        locale?: string;
+    });
+    request<T = unknown>(path: string, options?: ApiRequestOptions): Promise<T>;
+    response(path: string, options?: ApiRequestOptions): Promise<Response>;
+    private send;
+}

package/dist/client/api-client.js

@@ -0,0 +1,64 @@
+import { apiError } from './errors.js';
+export class ApiClient {
+    baseUrl;
+    fetcher;
+    locale;
+    session;
+    constructor(input) {
+        this.baseUrl = input.baseUrl.replace(/\/+$/, '');
+        this.session = input.session;
+        this.fetcher = input.fetcher ?? fetch;
+        this.locale = input.locale ?? 'zh';
+    }
+    async request(path, options = {}) {
+        const firstToken = options.auth === false ? null : await this.session.accessToken();
+        let response = await this.send(path, options, firstToken);
+        if (response.status === 401 && options.auth !== false) {
+            response = await this.send(path, options, await this.session.refreshAccessToken());
+        }
+        if (!response.ok)
+            throw await apiError(response);
+        if (response.status === 204)
+            return undefined;
+        return await response.json();
+    }
+    async response(path, options = {}) {
+        const firstToken = options.auth === false ? null : await this.session.accessToken();
+        let response = await this.send(path, options, firstToken);
+        if (response.status === 401 && options.auth !== false) {
+            response = await this.send(path, options, await this.session.refreshAccessToken());
+        }
+        if (!response.ok)
+            throw await apiError(response);
+        return response;
+    }
+    async send(path, options, accessToken) {
+        const { auth: _auth, body: inputBody, ...requestInit } = options;
+        const headers = new Headers(requestInit.headers);
+        headers.set('accept', 'application/json');
+        headers.set('accept-language', this.locale);
+        if (accessToken)
+            headers.set('authorization', `Bearer ${accessToken}`);
+        let body = inputBody;
+        if (inputBody !== undefined && isJsonBody(inputBody)) {
+            headers.set('content-type', 'application/json');
+            body = JSON.stringify(inputBody);
+        }
+        const url = /^https?:\/\//i.test(path)
+            ? path
+            : `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+        return this.fetcher(url, {
+            ...requestInit,
+            headers,
+            body,
+        });
+    }
+}
+function isJsonBody(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !(value instanceof ArrayBuffer)
+        && !(value instanceof Blob)
+        && !(value instanceof FormData)
+        && !(value instanceof URLSearchParams);
+}

package/dist/client/errors.d.ts

@@ -0,0 +1,14 @@
+export declare class CliApiError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    readonly retryable: boolean;
+    readonly status: number;
+    constructor(input: {
+        code: string;
+        message: string;
+        status: number;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+    });
+}
+export declare function apiError(response: Response): Promise<CliApiError>;

package/dist/client/errors.js

@@ -0,0 +1,34 @@
+export class CliApiError extends Error {
+    code;
+    details;
+    retryable;
+    status;
+    constructor(input) {
+        super(input.message);
+        this.name = 'CliApiError';
+        this.code = input.code;
+        this.status = input.status;
+        this.retryable = input.retryable ?? false;
+        this.details = input.details ?? {};
+    }
+}
+export async function apiError(response) {
+    const payload = await response.json().catch(() => null);
+    const nested = payload?.error && typeof payload.error === 'object' && !Array.isArray(payload.error)
+        ? payload.error
+        : null;
+    const code = readString(nested?.code) || readString(payload?.code) || `HTTP_${response.status}`;
+    const message = readString(nested?.message) || readString(payload?.message) || response.statusText || 'API 请求失败';
+    return new CliApiError({
+        code,
+        message,
+        status: response.status,
+        retryable: nested?.retryable === true,
+        details: nested?.details && typeof nested.details === 'object' && !Array.isArray(nested.details)
+            ? nested.details
+            : {},
+    });
+}
+function readString(value) {
+    return typeof value === 'string' ? value : '';
+}

package/dist/command-helpers.d.ts

@@ -0,0 +1,10 @@
+import { createRuntime } from './runtime.js';
+import { VvicatApi } from './domain/vvicat-api.js';
+export declare const projectFlag: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+export declare function commandApi(flags: Parameters<typeof createRuntime>[0]): Promise<{
+    api: VvicatApi;
+    profile: import("./config/profiles.js").CliProfile;
+    session: import("./auth/session-manager.js").SessionManager;
+    client: import("./client/api-client.js").ApiClient;
+}>;
+export declare function readJsonInput(file?: string): Promise<Record<string, unknown>>;

package/dist/command-helpers.js

@@ -0,0 +1,24 @@
+import { readFile } from 'node:fs/promises';
+import { Flags } from '@oclif/core';
+import { createRuntime } from './runtime.js';
+import { VvicatApi } from './domain/vvicat-api.js';
+export const projectFlag = Flags.string({ description: '无限画布项目 ID', required: true });
+export async function commandApi(flags) {
+    const runtime = await createRuntime(flags);
+    return { ...runtime, api: new VvicatApi(runtime.client) };
+}
+export async function readJsonInput(file) {
+    const source = file ? await readFile(file, 'utf8') : await readStdin();
+    const value = JSON.parse(source);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('输入必须是 JSON 对象');
+    return value;
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        throw new Error('请使用 --file 或通过 stdin 传入 JSON');
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command.js';
+export default class AuthLogin extends BaseCommand {
+    static description: string;
+    static flags: {
+        email: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        google: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'password-stdin': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        locale: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/login.js

@@ -0,0 +1,32 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { createRuntime } from '../../runtime.js';
+import { promptLine, promptPassword } from '../../terminal/prompt.js';
+export default class AuthLogin extends BaseCommand {
+    static description = '登录并将 refresh token 保存到系统钥匙串';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        email: Flags.string({ description: '登录邮箱' }),
+        google: Flags.boolean({ description: '通过浏览器使用 Google 登录', default: false }),
+        'password-stdin': Flags.boolean({ description: '从标准输入读取密码', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(AuthLogin);
+        const runtime = await createRuntime(flags);
+        if (flags.google) {
+            await runtime.session.loginWithGoogle();
+        }
+        else {
+            const email = flags.email || await promptLine('邮箱: ');
+            const password = flags['password-stdin'] ? await readStdin() : await promptPassword('密码: ');
+            await runtime.session.login(email, password.trimEnd());
+        }
+        this.print({ authenticated: true, profile: runtime.profile.name });
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/commands/auth/logout.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base-command.js';
+export default class AuthLogout extends BaseCommand {
+    static description: string;
+    static flags: {
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        locale: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/logout.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command.js';
+import { createRuntime } from '../../runtime.js';
+export default class AuthLogout extends BaseCommand {
+    static description = '注销并清除本机 refresh token';
+    static flags = BaseCommand.baseFlags;
+    async run() {
+        const { flags } = await this.parse(AuthLogout);
+        const runtime = await createRuntime(flags);
+        await runtime.session.logout();
+        this.print({ authenticated: false, profile: runtime.profile.name });
+    }
+}

package/dist/commands/auth/status.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base-command.js';
+export default class AuthStatus extends BaseCommand {
+    static description: string;
+    static flags: {
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        locale: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command.js';
+import { createRuntime } from '../../runtime.js';
+export default class AuthStatus extends BaseCommand {
+    static description = '检查当前登录状态';
+    static flags = BaseCommand.baseFlags;
+    async run() {
+        const { flags } = await this.parse(AuthStatus);
+        const runtime = await createRuntime(flags);
+        const payload = await runtime.client.request('/api/auth/session');
+        this.print({ authenticated: true, profile: runtime.profile.name, ...payload });
+    }
+}