monacloud-mcp 0.1.0

package/dist/clients.js

@@ -0,0 +1,157 @@
+import { randomUUID } from 'node:crypto';
+import { readLinks, writeLinks } from './auth.js';
+import { CloudError } from './errors.js';
+import { requestJson, unwrapData } from './http.js';
+const asObject = (value) => (value && typeof value === 'object' ? value : {});
+function pickString(objects, keys) {
+    for (const object of objects) {
+        for (const key of keys) {
+            const value = object[key];
+            if (typeof value === 'string' && value)
+                return value;
+        }
+    }
+    return undefined;
+}
+export class CloudClients {
+    config;
+    auth;
+    fetchImpl;
+    constructor(config, auth, fetchImpl = fetch) {
+        this.config = config;
+        this.auth = auth;
+        this.fetchImpl = fetchImpl;
+    }
+    async billing(path, options = {}) {
+        return requestJson(`${this.config.billingUrl}${path}`, {
+            ...options,
+            token: await this.auth.accessToken(),
+            fetchImpl: this.fetchImpl,
+        });
+    }
+    balance() {
+        return this.billing('/v1/balance');
+    }
+    ledger(cursor, limit = 50) {
+        return this.billing('/v1/ledger', { query: { cursor, limit } });
+    }
+    usage(period, product) {
+        return this.billing('/v1/usage', { query: { period, product } });
+    }
+    topup(amount, idempotencyKey) {
+        return this.billing('/v1/topups', {
+            method: 'POST',
+            headers: { 'Idempotency-Key': idempotencyKey || `mcp-topup-${randomUUID()}` },
+            body: { amount_vnd: amount },
+        });
+    }
+    budgetSet(body) {
+        return this.billing('/v1/budgets', { method: 'POST', body });
+    }
+    budgetGet() {
+        return this.billing('/v1/budgets');
+    }
+    async tokenLimit(spendLimitVnd, period, tokenId) {
+        const token = await this.auth.accessToken();
+        const id = tokenId || this.auth.tokenId(token);
+        return requestJson(`${this.config.billingUrl}/v1/tokens/${encodeURIComponent(id)}/limit`, {
+            method: 'PUT',
+            token,
+            body: { spend_limit_vnd: spendLimitVnd, period },
+            fetchImpl: this.fetchImpl,
+        });
+    }
+    async spendGuard() {
+        const current = asObject(await this.balance());
+        const balance = current.balance_vnd;
+        if (typeof balance === 'number' && balance <= 0) {
+            throw new CloudError('insufficient_funds', 'Ví thiếu tiền: số dư hiện tại là 0 đ.', `Nạp ví tại ${this.config.consoleUrl} rồi gọi lại tool.`);
+        }
+        return current;
+    }
+    async vibecloudToken() {
+        if (this.auth.env.VIBECLOUD_API_TOKEN)
+            return this.auth.env.VIBECLOUD_API_TOKEN;
+        const links = await readLinks(this.config);
+        if (links.vibecloud?.token
+            && (!links.vibecloud.expires_at || links.vibecloud.expires_at > Date.now() + 30_000)) {
+            return links.vibecloud.token;
+        }
+        return this.auth.accessToken();
+    }
+    async vibecloud(path, options = {}) {
+        return requestJson(`${this.config.vibecloudApi}${path}`, {
+            ...options,
+            token: await this.vibecloudToken(),
+            fetchImpl: this.fetchImpl,
+        });
+    }
+    async vibecloudLink() {
+        if (this.auth.env.VIBECLOUD_API_TOKEN) {
+            return { linked: true, product: 'vibecloud', mode: 'legacy_env', next_step: 'Dùng các tool vibecloud_*.' };
+        }
+        const monaIdToken = await this.auth.accessToken();
+        try {
+            await requestJson(`${this.config.vibecloudApi}/api/services`, {
+                token: monaIdToken,
+                fetchImpl: this.fetchImpl,
+            });
+            return {
+                linked: true,
+                product: 'vibecloud',
+                mode: 'direct_mona_id',
+                next_step: 'VibeCloud đã nhận MONA ID trực tiếp; không cần cache vc_live token.',
+            };
+        }
+        catch (error) {
+            if (!(error instanceof CloudError) || ![401, 403].includes(error.status || 0))
+                throw error;
+        }
+        const value = await requestJson(`${this.config.vibecloudApi}${this.config.vibecloudLinkPath}`, {
+            method: 'POST',
+            token: monaIdToken,
+            body: { source: 'monacloud-mcp' },
+            fetchImpl: this.fetchImpl,
+        });
+        const root = asObject(value);
+        const data = asObject(unwrapData(value));
+        const token = pickString([data, root], ['api_token', 'access_token', 'token', 'vibecloud_token']);
+        if (!token) {
+            throw new CloudError('invalid_link_response', 'VibeCloud không trả automation token sau khi liên kết.', 'Kiểm tra endpoint chuyển tiếp MONA ID của VibeCloud rồi gọi lại vibecloud_link.');
+        }
+        const expiresIn = Number(data.expires_in ?? root.expires_in);
+        const links = await readLinks(this.config);
+        links.vibecloud = {
+            token,
+            ...(Number.isFinite(expiresIn) ? { expires_at: Date.now() + expiresIn * 1000 } : {}),
+            linked_at: new Date().toISOString(),
+        };
+        await writeLinks(this.config, links);
+        return { linked: true, product: 'vibecloud', next_step: 'Dùng các tool vibecloud_* bằng cùng MONA ID.' };
+    }
+    async monapayLink() {
+        const value = await requestJson(`${this.config.monapayApi}${this.config.monapayLinkPath}`, {
+            method: 'POST',
+            token: await this.auth.accessToken(),
+            body: { source: 'monacloud-mcp' },
+            fetchImpl: this.fetchImpl,
+        });
+        const root = asObject(value);
+        const data = asObject(unwrapData(value));
+        const clientId = pickString([data, root], ['client_id', 'clientId']);
+        const clientSecret = pickString([data, root], ['client_secret', 'clientSecret']);
+        if (!clientId || !clientSecret) {
+            throw new CloudError('invalid_link_response', 'MONA Pay chưa trả đủ client_id/client_secret sau khi liên kết.', 'Nếu tài khoản cũ cần OTP liên kết, hoàn tất OTP theo hướng dẫn MONA Pay rồi gọi lại monapay_link.');
+        }
+        const links = await readLinks(this.config);
+        links.monapay = { client_id: clientId, client_secret: clientSecret, linked_at: new Date().toISOString() };
+        await writeLinks(this.config, links);
+        return { linked: true, product: 'monapay', next_step: 'Dùng các tool monapay_* bằng cùng MONA ID.' };
+    }
+    prices() {
+        return requestJson(`${this.config.vibecloudApi}/api/prices`, { fetchImpl: this.fetchImpl });
+    }
+    packages() {
+        return requestJson(`${this.config.vibecloudApi}/api/packages`, { fetchImpl: this.fetchImpl });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export type Config = {
+    issuer: string;
+    billingUrl: string;
+    monapayApi: string;
+    vibecloudApi: string;
+    consoleUrl: string;
+    clientId: string;
+    scope: string;
+    configDir: string;
+    tokenFile: string;
+    linksFile: string;
+    templatesDir: string;
+    templatesUrl?: string;
+    monapayLinkPath: string;
+    vibecloudLinkPath: string;
+};
+export declare function readConfig(env?: NodeJS.ProcessEnv): Config;

package/dist/config.js

@@ -0,0 +1,25 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const cleanBaseUrl = (value) => value.replace(/\/+$/, '');
+export function readConfig(env = process.env) {
+    const configDir = env.MONACLOUD_CONFIG_DIR
+        || join(env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'monacloud');
+    return {
+        issuer: cleanBaseUrl(env.MONACLOUD_ISSUER || 'https://id.monacloud.vn/realms/mona'),
+        billingUrl: cleanBaseUrl(env.MONACLOUD_BILLING_URL || 'https://billing.monacloud.vn'),
+        monapayApi: cleanBaseUrl(env.MONAPAY_API || env.MONAPAY_BASE_URL || 'https://api.monapay.vn'),
+        vibecloudApi: cleanBaseUrl(env.VIBECLOUD_API || env.VIBECLOUD_API_URL || 'https://api.vibecloud.vn'),
+        consoleUrl: cleanBaseUrl(env.MONACLOUD_CONSOLE_URL || 'https://monacloud.vn/console'),
+        clientId: env.MONACLOUD_CLIENT_ID || 'monacloud-mcp',
+        scope: env.MONACLOUD_SCOPE || 'openid profile email product billing-api offline_access',
+        configDir,
+        tokenFile: join(configDir, 'token.json'),
+        linksFile: join(configDir, 'links.json'),
+        templatesDir: env.MONACLOUD_TEMPLATES_DIR || join(homedir(), 'monacloud', 'templates'),
+        templatesUrl: env.MONACLOUD_TEMPLATES_URL
+            ? cleanBaseUrl(env.MONACLOUD_TEMPLATES_URL)
+            : undefined,
+        monapayLinkPath: env.MONAPAY_LINK_PATH || '/api/v1/client/oauth/mona-id/link',
+        vibecloudLinkPath: env.VIBECLOUD_LINK_PATH || '/api/auth/monaid/link',
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,38 @@
+export type AgentErrorPayload = {
+    code: string;
+    message: string;
+    next_step: string;
+    request_id?: string;
+};
+export declare class CloudError extends Error {
+    readonly code: string;
+    readonly nextStep: string;
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly requestId?: string;
+    constructor(code: string, message: string, nextStep: string, options?: {
+        status?: number;
+        details?: unknown;
+        requestId?: string;
+    });
+}
+export declare function toAgentError(error: unknown): AgentErrorPayload;
+export declare const textResult: (value: unknown) => {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+};
+export declare const errorResult: (error: unknown) => {
+    isError: boolean;
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+};
+export declare function runTool(fn: () => Promise<unknown> | unknown): Promise<{
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+}>;

package/dist/errors.js

@@ -0,0 +1,51 @@
+export class CloudError extends Error {
+    code;
+    nextStep;
+    status;
+    details;
+    requestId;
+    constructor(code, message, nextStep, options = {}) {
+        super(message);
+        this.name = 'CloudError';
+        this.code = code;
+        this.nextStep = nextStep;
+        this.status = options.status;
+        this.details = options.details;
+        this.requestId = options.requestId;
+    }
+}
+function safeMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return typeof error === 'string' ? error : 'Lỗi không xác định';
+}
+export function toAgentError(error) {
+    if (error instanceof CloudError) {
+        return {
+            code: error.code,
+            message: error.message,
+            next_step: error.nextStep,
+            ...(error.requestId ? { request_id: error.requestId } : {}),
+        };
+    }
+    return {
+        code: 'internal_error',
+        message: safeMessage(error),
+        next_step: 'Thử lại. Nếu lỗi lặp lại, kiểm tra cấu hình MCP và trạng thái tại monacloud://status.',
+    };
+}
+export const textResult = (value) => ({
+    content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+});
+export const errorResult = (error) => ({
+    isError: true,
+    content: [{ type: 'text', text: JSON.stringify(toAgentError(error), null, 2) }],
+});
+export async function runTool(fn) {
+    try {
+        return textResult(await fn());
+    }
+    catch (error) {
+        return errorResult(error);
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,11 @@
+export type HttpOptions = {
+    method?: string;
+    token?: string;
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+};
+export declare function requestJson<T = unknown>(url: string, options?: HttpOptions): Promise<T>;
+export declare function unwrapData<T = unknown>(value: unknown): T;

package/dist/http.js

@@ -0,0 +1,76 @@
+import { CloudError } from './errors.js';
+const asRecord = (value) => (value && typeof value === 'object' ? value : {});
+const nestedString = (body, key) => {
+    const value = body[key];
+    if (typeof value === 'string' && value)
+        return value;
+    const detail = asRecord(body.detail);
+    const nested = detail[key];
+    return typeof nested === 'string' && nested ? nested : undefined;
+};
+function apiError(response, body) {
+    const parsed = asRecord(body);
+    const requestId = response.headers.get('x-request-id')
+        || nestedString(parsed, 'request_id');
+    const detail = parsed.detail;
+    const code = nestedString(parsed, 'code')
+        || (typeof detail === 'string' && /^[a-z0-9_]+$/i.test(detail) ? detail : undefined)
+        || (response.status === 401 ? 'auth_required' : `http_${response.status}`);
+    const rawMessage = nestedString(parsed, 'message')
+        || (typeof detail === 'string' ? detail : undefined)
+        || `HTTP ${response.status}`;
+    if (response.status === 402 || code === 'budget_exceeded' || code === 'insufficient_funds') {
+        const shortage = parsed.shortage_vnd ?? parsed.missing_vnd ?? asRecord(detail).shortage_vnd;
+        const missing = typeof shortage === 'number' ? `${shortage.toLocaleString('vi-VN')} đ` : 'tiền';
+        return new CloudError(code === 'budget_exceeded' ? 'budget_exceeded' : 'insufficient_funds', `Ví thiếu ${missing} hoặc đã chạm giới hạn chi tiêu. ${rawMessage}`, 'Nạp ví hoặc tăng ngân sách tại https://monacloud.vn/console rồi gọi lại tool.', { status: response.status, details: body, requestId });
+    }
+    if (response.status === 401 || response.status === 403) {
+        return new CloudError(code, `Token không có quyền hoặc đã hết hạn. ${rawMessage}`, 'Chạy `monacloud-mcp login` rồi thử lại; kiểm tra audience/scope nếu lỗi vẫn còn.', { status: response.status, details: body, requestId });
+    }
+    return new CloudError(code, rawMessage, response.status >= 500
+        ? 'Kiểm tra monacloud://status rồi thử lại.'
+        : 'Kiểm tra tham số theo mô tả tool rồi gọi lại.', { status: response.status, details: body, requestId });
+}
+export async function requestJson(url, options = {}) {
+    const parsedUrl = new URL(url);
+    for (const [key, value] of Object.entries(options.query || {})) {
+        if (value !== undefined && value !== '')
+            parsedUrl.searchParams.set(key, String(value));
+    }
+    const headers = {
+        Accept: 'application/json',
+        ...(options.token ? { Authorization: `Bearer ${options.token}` } : {}),
+        ...options.headers,
+    };
+    if (options.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    let response;
+    try {
+        response = await (options.fetchImpl || fetch)(parsedUrl, {
+            method: options.method || 'GET',
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            ...(options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}),
+        });
+    }
+    catch (error) {
+        throw new CloudError('network_error', `Không kết nối được ${parsedUrl.origin}: ${error instanceof Error ? error.message : String(error)}`, 'Kiểm tra mạng, URL cấu hình và monacloud://status rồi thử lại.');
+    }
+    const text = await response.text();
+    let body = {};
+    if (text) {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = { message: text.slice(0, 1000) };
+        }
+    }
+    if (!response.ok)
+        throw apiError(response, body);
+    return body;
+}
+export function unwrapData(value) {
+    const body = asRecord(value);
+    return (body.data === undefined ? value : body.data);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { AuthManager } from './auth.js';
+import { readConfig } from './config.js';
+import { toAgentError } from './errors.js';
+import { createServer } from './server.js';
+const command = process.argv[2];
+const config = readConfig();
+const auth = new AuthManager(config);
+async function main() {
+    if (command === 'login') {
+        await auth.login();
+        return;
+    }
+    if (command === 'logout') {
+        const removed = await auth.logout();
+        console.log(removed ? 'Đã đăng xuất MONA Cloud.' : 'Máy chưa có token MONA Cloud.');
+        return;
+    }
+    if (command === 'whoami') {
+        console.log(JSON.stringify(await auth.userinfo(), null, 2));
+        return;
+    }
+    if (command === '--version' || command === '-v') {
+        console.log('0.1.0');
+        return;
+    }
+    if (command === '--help' || command === '-h' || command === 'help') {
+        console.log('Usage: monacloud-mcp [login|logout|whoami|--version]\nKhông có command: chạy MCP server qua stdio.');
+        return;
+    }
+    if (command) {
+        throw new Error(`Command không hỗ trợ: ${command}`);
+    }
+    await createServer().connect(new StdioServerTransport());
+}
+main().catch((error) => {
+    console.error(JSON.stringify(toAgentError(error)));
+    process.exitCode = 1;
+});

package/dist/monapay.d.ts

@@ -0,0 +1,16 @@
+import { MonaPayClient } from 'monapay-mcp/dist/client.js';
+import type { Config } from './config.js';
+type ImportedTool = {
+    title?: string;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    annotations?: unknown;
+    _meta?: Record<string, unknown>;
+    handler: (...args: unknown[]) => unknown;
+    enabled: boolean;
+};
+export declare function createMonaPayClient(config: Config, env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch): MonaPayClient;
+export declare function importedMonaPayTools(config: Config, env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch): Record<string, ImportedTool>;
+export declare function normalizeImportedResult(result: unknown): Promise<unknown>;
+export {};

package/dist/monapay.js

@@ -0,0 +1,49 @@
+import { readFileSync } from 'node:fs';
+import { createServer as createMonaPayServer } from 'monapay-mcp';
+import { MonaPayClient } from 'monapay-mcp/dist/client.js';
+import { CloudError, errorResult } from './errors.js';
+function linkedCredentials(config) {
+    try {
+        const parsed = JSON.parse(readFileSync(config.linksFile, 'utf8'));
+        if (parsed.monapay?.client_id && parsed.monapay.client_secret) {
+            return { client_id: parsed.monapay.client_id, client_secret: parsed.monapay.client_secret };
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw new CloudError('invalid_link_store', 'Không đọc được credential MONA Pay đã liên kết.', 'Xoá links.json trong thư mục cấu hình rồi gọi monapay_link lại.');
+        }
+    }
+    return undefined;
+}
+export function createMonaPayClient(config, env = process.env, fetchImpl = fetch) {
+    const clientId = env.MONAPAY_CLIENT_ID;
+    const clientSecret = env.MONAPAY_CLIENT_SECRET;
+    if (clientId && clientSecret) {
+        return new MonaPayClient({ clientId, clientSecret, baseUrl: config.monapayApi, fetchImpl });
+    }
+    const linked = linkedCredentials(config);
+    if (linked) {
+        return new MonaPayClient({
+            clientId: linked.client_id,
+            clientSecret: linked.client_secret,
+            baseUrl: config.monapayApi,
+            fetchImpl,
+        });
+    }
+    throw new CloudError('monapay_link_required', 'MONA Pay đang ở giai đoạn chuyển tiếp và chưa được liên kết với MONA ID này.', 'Gọi monapay_link một lần; nếu hệ thống yêu cầu OTP thì hoàn tất OTP rồi thử lại.');
+}
+export function importedMonaPayTools(config, env = process.env, fetchImpl = fetch) {
+    const imported = createMonaPayServer(() => createMonaPayClient(config, env, fetchImpl));
+    return imported._registeredTools;
+}
+export async function normalizeImportedResult(result) {
+    const value = await result;
+    if (!value || typeof value !== 'object')
+        return value;
+    const response = value;
+    if (!response.isError)
+        return response;
+    const message = response.content?.find((item) => item.type === 'text')?.text || 'MONA Pay trả lỗi.';
+    return errorResult(new CloudError('monapay_error', message, 'Kiểm tra tham số và trạng thái liên kết MONA Pay; gọi monapay_link nếu credential chuyển tiếp đã hết hiệu lực.'));
+}

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Config } from './config.js';
+export type ServerDependencies = {
+    config?: Config;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: typeof fetch;
+};
+export declare function createServer(dependencies?: ServerDependencies): McpServer;