@qmuse/qmuse-cli 1.0.0-dev.0

package/dist/client.js

@@ -0,0 +1,148 @@
+/**
+ * QMuse HTTP 客户端：
+ *  - 拼接 baseUrl + apiPrefix + 路径
+ *  - 仅向登录时绑定的 API Origin 注入 sessionId
+ *  - 兼容两种响应包装：
+ *      * CommonHttpResult<T> = { success, data?, errorCode?, errorMessage?, traceId? }
+ *      * IQmuseResult<T>     = { success, errorCode, errorMessage, retriable?, resultObj? }
+ */
+import { apiOrigin, loadConfig } from './config.js';
+import { QMUSE_CLI_DISTRIBUTION, QMUSE_CLI_NAME, QMUSE_CLI_VERSION, } from './version.js';
+/** 拼接完整请求地址。 */
+export function buildUrl(cfg, path) {
+    const base = cfg.baseUrl.replace(/\/+$/, '');
+    const prefix = cfg.apiPrefix || '';
+    return `${base}${prefix}${path}`;
+}
+export function requestSourceHeaders(cfg) {
+    const origin = apiOrigin(cfg.webBaseUrl);
+    if (!origin)
+        throw new Error('QMuse Web 地址不是有效的 HTTP(S) 地址');
+    return {
+        Referer: `${origin}/`,
+        Origin: origin,
+        'x-qmuse-client': QMUSE_CLI_NAME,
+        'x-qmuse-client-version': QMUSE_CLI_VERSION,
+        'x-qmuse-client-distribution': QMUSE_CLI_DISTRIBUTION,
+    };
+}
+function credentialMatchesTarget(cfg) {
+    const expected = (cfg.credentialOrigin || '').trim();
+    const target = apiOrigin(cfg.baseUrl);
+    return !!expected && !!target && expected === target;
+}
+/** 构造鉴权请求头；凭证与请求 Origin 不匹配时不会发送凭证。 */
+export function authHeaders(cfg) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'x-qmuse-client': QMUSE_CLI_NAME,
+        'x-qmuse-client-version': QMUSE_CLI_VERSION,
+        'x-qmuse-client-distribution': QMUSE_CLI_DISTRIBUTION,
+    };
+    const sid = (cfg.sessionId || '').trim();
+    if (sid && credentialMatchesTarget(cfg)) {
+        headers['x-session-id'] = sid;
+        headers['Cookie'] = `muse_user=${sid}`;
+    }
+    // 当前操作空间（后端 UserAuthService 优先读 x-space-id 头，高于缓存）
+    const spaceId = (cfg.spaceId || '').trim();
+    if (spaceId) {
+        headers['x-space-id'] = spaceId;
+    }
+    return headers;
+}
+/** 是否缺少鉴权配置。 */
+export function hasAuth(cfg) {
+    return !!(cfg.sessionId || '').trim() && credentialMatchesTarget(cfg);
+}
+function extractData(json) {
+    if (json && typeof json === 'object' && typeof json.success === 'boolean') {
+        const ok = json.success === true;
+        // CommonHttpResult 优先取 data，IQmuseResult 取 resultObj
+        const data = json.data !== undefined ? json.data : json.resultObj;
+        return {
+            ok,
+            data: data,
+            errorCode: json.errorCode,
+            errorMessage: json.errorMessage,
+        };
+    }
+    // 非标准包装：按 HTTP 状态判定，原始体作为 data 返回
+    return { ok: false, data: json };
+}
+/** 发起一次 musepub 调用。 */
+export async function apiCall(method, path, body, cfgOverrideOrOpts) {
+    const opts = cfgOverrideOrOpts && typeof cfgOverrideOrOpts === 'object' && !('baseUrl' in cfgOverrideOrOpts)
+        ? cfgOverrideOrOpts
+        : { cfg: cfgOverrideOrOpts };
+    const cfg = opts.cfg ?? loadConfig();
+    const url = buildUrl(cfg, path);
+    const headers = opts.anonymous
+        ? {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            'x-qmuse-client': QMUSE_CLI_NAME,
+            'x-qmuse-client-version': QMUSE_CLI_VERSION,
+            'x-qmuse-client-distribution': QMUSE_CLI_DISTRIBUTION,
+        }
+        : authHeaders(cfg);
+    if (method === 'POST' && !headers['Referer']) {
+        Object.assign(headers, requestSourceHeaders(cfg));
+    }
+    const init = { method, headers };
+    if (body !== undefined && method !== 'GET') {
+        init.body = JSON.stringify(body);
+    }
+    let res;
+    try {
+        res = await fetch(url, init);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            status: 0,
+            raw: null,
+            setCookie: [],
+            errorCode: 'NETWORK_ERROR',
+            errorMessage: `请求失败 ${url}: ${msg}`,
+        };
+    }
+    let json = null;
+    const text = await res.text();
+    if (text) {
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = null;
+        }
+    }
+    const setCookie = readSetCookie(res);
+    const extracted = extractData(json);
+    return {
+        ok: extracted.ok,
+        data: extracted.data,
+        errorCode: extracted.errorCode,
+        errorMessage: extracted.errorMessage,
+        raw: json,
+        status: res.status,
+        setCookie,
+    };
+}
+/** 从响应读取所有 Set-Cookie 头（Node undici Headers.getSetCookie）。 */
+function readSetCookie(res) {
+    const h = res.headers;
+    if (typeof h.getSetCookie === 'function') {
+        try {
+            return h.getSetCookie() ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    // 回退：getSetCookie 不可用时从原始头拼接
+    const raw = res.headers.get('set-cookie');
+    return raw ? [raw] : [];
+}

package/dist/cloud.js

@@ -0,0 +1,36 @@
+import { apiCall } from './client.js';
+import { loadManagedProject } from './import/project.js';
+export const CLOUD_INIT_SUCCESS_MESSAGE = 'Cloud service entitlement verified successfully. Continue implementing the requested ' +
+    'cloud features by following the cloud service skill instructions.';
+function entitlementError(snapshot) {
+    if (snapshot.reason === 'CLOUD_SERVICE_LIMIT_EXCEEDED') {
+        const usage = snapshot.appLimit === undefined
+            ? ''
+            : `（已使用 ${snapshot.enabledAppCount ?? 0}/${snapshot.appLimit}）`;
+        return new Error(`当前空间云服务额度已满${usage}`);
+    }
+    return new Error('当前空间没有可用的云服务权益');
+}
+export async function checkCloudInit(rootDir, cfg, explicitEnvironment) {
+    const project = await loadManagedProject(rootDir, cfg, explicitEnvironment);
+    const appId = project?.target?.appId;
+    const spaceId = project?.target?.spaceId ||
+        project?.manifest.defaultSpaceId ||
+        cfg.spaceId;
+    if (!spaceId) {
+        throw new Error('请先执行 qmuse space use <spaceId>，或通过 --space-id 指定目标空间');
+    }
+    const response = appId
+        ? await apiCall('POST', '/api/appwrite/entitlement/check', { appId }, cfg)
+        : await apiCall('POST', '/api/appwrite/entitlement/space/check', { spaceId }, cfg);
+    if (!response.ok || !response.data) {
+        throw new Error(`校验 QMuse 云服务权益失败：${response.errorMessage ?? response.errorCode ?? `HTTP ${response.status}`}`);
+    }
+    if (!response.data.entitled)
+        throw entitlementError(response.data);
+    return {
+        ...response.data,
+        ...(appId ? { appId } : {}),
+        spaceId,
+    };
+}

package/dist/config.js

@@ -0,0 +1,118 @@
+/**
+ * QMuse CLI 配置。
+ *
+ * 登录凭证只从用户级配置读取；项目级配置只能提供空间选择，不能改变请求目标
+ * 或注入请求头。凭证同时绑定登录时的 API Origin，切换环境后必须重新登录。
+ */
+import { chmodSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_FILE = '.qmuse-cli.json';
+export const DEFAULT_CONFIG = {
+    baseUrl: 'https://api.qmuse.cn',
+    apiPrefix: '',
+    webBaseUrl: 'https://qmuse.cn',
+    sessionId: '',
+    credentialOrigin: '',
+};
+const ENVIRONMENT_CONFIG = {
+    prod: {
+        baseUrl: 'https://api.qmuse.cn',
+        apiPrefix: '',
+        webBaseUrl: 'https://qmuse.cn',
+    },
+    pre: {
+        baseUrl: 'https://api-pre.qmuse.cn',
+        apiPrefix: '',
+        webBaseUrl: 'https://qmuse-pre.qmuse.cn',
+    },
+    local: {
+        baseUrl: 'http://127.0.0.1:7001',
+        apiPrefix: '',
+        webBaseUrl: 'https://local.dev.qmuse.cn:8000',
+    },
+};
+/** 候选配置路径：项目级在前、用户级在后。 */
+export function configPaths() {
+    return [join(process.cwd(), CONFIG_FILE), join(homedir(), CONFIG_FILE)];
+}
+function readConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function apiOrigin(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.origin : '';
+    }
+    catch {
+        return '';
+    }
+}
+function storedEnvironment(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.replace(/\/+$/u, '');
+    return Object.values(ENVIRONMENT_CONFIG).find(environment => environment.baseUrl === normalized);
+}
+/**
+ * 加载配置。项目配置即使由仓库提交，也只能覆盖 spaceId。
+ * 旧配置没有 credentialOrigin 时，将凭证绑定到用户配置自身的 baseUrl。
+ */
+export function loadConfig(paths = configPaths()) {
+    const [projectPath, userPath] = paths;
+    const user = readConfig(userPath);
+    const project = readConfig(projectPath);
+    const storedEndpoint = storedEnvironment(user.baseUrl);
+    const sessionId = storedEndpoint && typeof user.sessionId === 'string'
+        ? user.sessionId.trim()
+        : '';
+    const credentialOrigin = sessionId
+        ? (typeof user.credentialOrigin === 'string' && user.credentialOrigin.trim()
+            ? user.credentialOrigin.trim()
+            : apiOrigin(storedEndpoint?.baseUrl ?? ''))
+        : '';
+    return {
+        ...DEFAULT_CONFIG,
+        sessionId,
+        credentialOrigin,
+        ...(typeof user.spaceId === 'string' && user.spaceId.trim()
+            ? { spaceId: user.spaceId.trim() }
+            : {}),
+        ...(typeof project.spaceId === 'string' && project.spaceId.trim()
+            ? { spaceId: project.spaceId.trim() }
+            : {}),
+    };
+}
+export function applyEnvironment(cfg, environment) {
+    return { ...cfg, ...ENVIRONMENT_CONFIG[environment] };
+}
+/** 保存配置。项目级文件仅允许保存不敏感的空间选择。 */
+export function saveConfig(cfg, global = true) {
+    const path = global ? join(homedir(), CONFIG_FILE) : join(process.cwd(), CONFIG_FILE);
+    const value = global
+        ? cfg
+        : { ...(cfg.spaceId ? { spaceId: cfg.spaceId } : {}) };
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    chmodSync(path, 0o600);
+    return path;
+}
+export function findConfigPath() {
+    for (const path of configPaths()) {
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}

package/dist/import/api.js

@@ -0,0 +1,57 @@
+import { openAsBlob } from 'node:fs';
+import { apiCall, authHeaders, buildUrl, requestSourceHeaders, } from '../client.js';
+export async function uploadImportArchive(input, cfg) {
+    const archive = await openAsBlob(input.filePath, { type: 'application/zip' });
+    const headers = authHeaders(cfg);
+    headers['Content-Type'] = 'application/zip';
+    headers['Content-Length'] = String(archive.size);
+    headers['x-space-id'] = input.spaceId;
+    Object.assign(headers, requestSourceHeaders(cfg));
+    let response;
+    try {
+        response = await fetch(buildUrl(cfg, '/api/app-import/source'), {
+            method: 'POST',
+            headers,
+            body: archive,
+        });
+    }
+    catch (error) {
+        throw new Error(`上传源码失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch {
+        throw new Error('上传源码失败：服务端响应格式错误');
+    }
+    if (!response.ok || result.success !== true || !result.data?.sourceToken) {
+        throw new Error(`上传源码失败：${result.errorMessage ?? result.errorCode ?? `HTTP ${response.status}`}`);
+    }
+    return result.data.sourceToken;
+}
+export function startAppImport(body, cfg) {
+    return apiCall('POST', '/api/app-import/start', body, cfg);
+}
+export function queryAppImportStatus(jobId, cfg) {
+    return apiCall('POST', '/api/app-import/status', { jobId }, cfg);
+}
+export function configureAppImport(body, cfg) {
+    return apiCall('POST', '/api/app-import/configure', body, cfg);
+}
+export function getAppOpenUrl(webBaseUrl, appId) {
+    let base;
+    try {
+        base = new URL(webBaseUrl);
+    }
+    catch {
+        throw new Error(`QMuse Web 地址无效：${webBaseUrl}`);
+    }
+    if (!['http:', 'https:'].includes(base.protocol)) {
+        throw new Error(`QMuse Web 地址必须使用 HTTP(S)：${webBaseUrl}`);
+    }
+    return new URL(`/app/${encodeURIComponent(appId)}`, base).toString();
+}
+export function getImportStatusUrl(cfg) {
+    return buildUrl(cfg, '/api/app-import/status');
+}

package/dist/import/archive.js

@@ -0,0 +1,52 @@
+import { createWriteStream } from 'node:fs';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { ZipFile } from 'yazl';
+import { createSourceManifest, SOURCE_MANIFEST_PATH } from './source-manifest.js';
+const MAX_ARCHIVE_BYTES = 500 * 1024 * 1024;
+const STABLE_ZIP_MTIME = new Date('1980-01-01T00:00:00.000Z');
+export async function createImportArchive(preflight) {
+    const temporaryDirectory = await mkdtemp(path.join(tmpdir(), 'qmuse-import-'));
+    const fileName = `${path.basename(preflight.rootDir)}.zip`;
+    const filePath = path.join(temporaryDirectory, fileName);
+    const zip = new ZipFile();
+    const output = createWriteStream(filePath, { mode: 0o600 });
+    const completed = new Promise((resolve, reject) => {
+        output.once('close', resolve);
+        output.once('error', reject);
+        zip.outputStream.once('error', reject);
+    });
+    zip.outputStream.pipe(output);
+    for (const file of preflight.files) {
+        zip.addFile(file.absolutePath, file.relativePath, {
+            mtime: STABLE_ZIP_MTIME,
+            mode: 0o100644,
+            compress: true,
+        });
+    }
+    zip.addBuffer(Buffer.from(`${JSON.stringify(createSourceManifest(preflight), null, 2)}\n`, 'utf8'), SOURCE_MANIFEST_PATH, {
+        mtime: STABLE_ZIP_MTIME,
+        mode: 0o100644,
+        compress: true,
+    });
+    zip.end();
+    try {
+        await completed;
+        const sizeBytes = (await stat(filePath)).size;
+        if (sizeBytes <= 0)
+            throw new Error('生成的源码压缩包为空');
+        if (sizeBytes > MAX_ARCHIVE_BYTES)
+            throw new Error('源码压缩包超过 500MB');
+        return {
+            filePath,
+            fileName,
+            sizeBytes,
+            cleanup: () => rm(temporaryDirectory, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        await rm(temporaryDirectory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/import/diagnostic.js

@@ -0,0 +1,39 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const QMUSE_IMPORT_DIAGNOSTIC_PATH = '.qmuse/last-import-error.json';
+export async function writeImportFailureDiagnostic(input) {
+    if (input.status.status !== 'FAILED') {
+        throw new Error('只能为失败的导入任务写入诊断文件');
+    }
+    const filePath = path.join(input.rootDir, QMUSE_IMPORT_DIAGNOSTIC_PATH);
+    const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const payload = {
+        schemaVersion: 1,
+        jobId: input.status.jobId,
+        status: input.status.status,
+        stage: input.status.stage,
+        message: input.status.message,
+        diagnostic: input.status.diagnostic,
+        failureDiagnostic: input.status.failureDiagnostic,
+        retryCommand: 'qmuse import .',
+        generatedAt: new Date().toISOString(),
+    };
+    try {
+        await writeFile(temporaryPath, `${JSON.stringify(payload, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+            flag: 'wx',
+        });
+        await rename(temporaryPath, filePath);
+    }
+    catch (error) {
+        await rm(temporaryPath, { force: true });
+        throw error;
+    }
+    return filePath;
+}
+export async function clearImportFailureDiagnostic(rootDir) {
+    await rm(path.join(rootDir, QMUSE_IMPORT_DIAGNOSTIC_PATH), { force: true });
+}

package/dist/import/poll.js

@@ -0,0 +1,45 @@
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_POLL_TIMEOUT_MS = 35 * 60 * 1_000;
+const MAX_CONSECUTIVE_RETRIABLE_ERRORS = 5;
+function isRetriable(result) {
+    return result.status === 0 || result.status === 429 || result.status >= 500;
+}
+function apiFailure(result) {
+    return new Error(`查询导入任务失败：${result.errorMessage ?? result.errorCode ?? `HTTP ${result.status}`}`);
+}
+export async function pollAppImport(query, options = {}) {
+    const now = options.now ?? Date.now;
+    const wait = options.wait ?? (milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds)));
+    const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const deadline = now() + (options.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS);
+    let consecutiveErrors = 0;
+    let lastStatus;
+    while (now() < deadline) {
+        if (options.signal?.aborted) {
+            return { reason: 'INTERRUPTED', status: lastStatus };
+        }
+        const result = await query();
+        if (!result.ok || !result.data) {
+            if (!isRetriable(result) || ++consecutiveErrors > MAX_CONSECUTIVE_RETRIABLE_ERRORS) {
+                throw apiFailure(result);
+            }
+        }
+        else {
+            consecutiveErrors = 0;
+            lastStatus = result.data;
+            options.onStatus?.(result.data);
+            if (result.data.status === 'READY') {
+                return { reason: 'READY', status: result.data };
+            }
+            if (result.data.status === 'FAILED') {
+                return { reason: 'FAILED', status: result.data };
+            }
+            if (result.data.status === 'WAITING_CLOUD_CONFIRMATION' ||
+                result.data.status === 'NEEDS_CONFIGURATION') {
+                return { reason: 'CONFIGURATION_REQUIRED', status: result.data };
+            }
+        }
+        await wait(intervalMs);
+    }
+    throw new Error('等待导入任务超时，可使用 `qmuse import status <jobId> --wait` 继续查询');
+}