redskillhub-upload 1.0.0-alpha.1

package/cli/submit.mjs

@@ -0,0 +1,253 @@
+import { deriveIdentifier } from './pack.mjs';
+import { resolveApiBase, PATHS } from './config.mjs';
+import { ExitCodes, SkillhubUploadError } from './errors.mjs';
+import { compatibleFetch } from './fetch.mjs';
+import { redactMessage } from './redact.mjs';
+import { FALLBACK_CONTENT_TAGS } from './tags.mjs';
+
+const EDITABLE_FIELDS = new Set(['name', 'identifier', 'version', 'description', 'detail', 'tag']);
+const VALID_SOURCES = new Set(['original', 'repost']);
+const SENSITIVE_PAYLOAD_FIELDS = new Set([
+  'access_token',
+  'refresh_token',
+  'token',
+  'bundle_file_id',
+  'bundle_sha256',
+  'skill_md_content'
+]);
+
+export const CONTENT_TAG_OPTIONS = FALLBACK_CONTENT_TAGS;
+
+function normalizeTagText(value) {
+  return String(value || '').trim().toLowerCase().replace(/\s+/g, '');
+}
+
+function resolveNamedTagId(rawTag, tagOptions) {
+  const normalized = normalizeTagText(rawTag);
+  const matched = tagOptions.find((tag) => {
+    const names = [tag.tagId, tag.name, ...(tag.aliases || [])];
+    return names.some((name) => normalizeTagText(name) === normalized);
+  });
+  return matched?.tagId || '';
+}
+
+function splitTagValues(value) {
+  if (value === undefined || value === null || value === '') {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(splitTagValues);
+  }
+  return String(value).split(/[，,]/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function formatContentTagOptions(tagOptions = FALLBACK_CONTENT_TAGS) {
+  return tagOptions.map((tag) => tag.name).join(' / ');
+}
+
+function resolveTagIds(flags, tagOptions = FALLBACK_CONTENT_TAGS) {
+  const rawTagId = flags.tagId ?? flags['tag-id'] ?? flags.tag;
+  const rawTags = splitTagValues(rawTagId);
+  if (rawTags.length === 0) {
+    return [];
+  }
+
+  const tagIds = [];
+  const seen = new Set();
+  for (const rawTag of rawTags) {
+    const tagId = /^\d+$/.test(rawTag) ? rawTag : resolveNamedTagId(rawTag, tagOptions);
+    if (!tagId) {
+      throw new Error(`未找到内容标签：${rawTag}，请选择：${formatContentTagOptions(tagOptions)}`);
+    }
+    if (seen.has(tagId)) {
+      continue;
+    }
+    seen.add(tagId);
+    tagIds.push(tagId);
+  }
+  return tagIds;
+}
+
+function resolveSourceFields(flags) {
+  if (flags.source === undefined || flags.source === null || flags.source === '') {
+    return {};
+  }
+
+  const source = String(flags.source).trim();
+  if (!VALID_SOURCES.has(source)) {
+    throw new Error('内容来源只能选择“原创”或“转载”');
+  }
+
+  if (source === 'original') {
+    return { original: true, repost_source: '' };
+  }
+
+  const repostSource = String(flags.repostSource ?? flags['repost-source'] ?? '').trim();
+  if (!repostSource) {
+    throw new Error('选择转载时，请填写转载来源');
+  }
+  return { original: false, repost_source: repostSource };
+}
+
+function stripVersionSuffix(value) {
+  return String(value || '').replace(/-v?\d+(\.\d+)*$/, '');
+}
+
+function resolveIdentifier(flags, metadata) {
+  if (flags.identifier) {
+    return String(flags.identifier).trim();
+  }
+  const fromName = deriveIdentifier(metadata.name || '');
+  if (fromName) {
+    return fromName;
+  }
+  const fromBaseName = deriveIdentifier(stripVersionSuffix(metadata.sourcePathBaseName || ''));
+  if (fromBaseName) {
+    return fromBaseName;
+  }
+  throw new Error(
+    `Skill ID 为空，无法从名称“${metadata.name || ''}”或目录名“${metadata.sourcePathBaseName || ''}”自动生成，请输入 Skill ID`
+  );
+}
+
+export function buildDraftPayload({ flags = {}, metadata = {}, bundle = {}, tagOptions = FALLBACK_CONTENT_TAGS }) {
+  const identifier = resolveIdentifier(flags, metadata);
+  const contentTagIds = resolveTagIds(flags, tagOptions);
+  const sourceFields = resolveSourceFields(flags);
+  return {
+    skill_identifier: identifier,
+    version: flags.version || metadata.version || '1.0.0',
+    name: flags.name || metadata.name || identifier,
+    description: flags.description || metadata.description || '',
+    skill_md_content: flags.detail || metadata.detail || '',
+    ...sourceFields,
+    content_tag_ids: contentTagIds,
+    bundle_file_id: bundle.bundleFileId || '',
+    bundle_sha256: bundle.bundleSha256,
+    bundle_size_bytes: bundle.bundleSizeBytes
+  };
+}
+
+export function applyConfirmEdit(payload, values, { tagOptions = FALLBACK_CONTENT_TAGS } = {}) {
+  for (const key of Object.keys(values)) {
+    if (!EDITABLE_FIELDS.has(key)) {
+      throw new Error(`提交确认阶段不能修改 ${key}，请取消后重新发布`);
+    }
+  }
+
+  return {
+    ...payload,
+    skill_identifier: values.identifier || payload.skill_identifier,
+    version: values.version || payload.version,
+    name: values.name || payload.name,
+    description: values.description || payload.description,
+    skill_md_content: values.detail || payload.skill_md_content,
+    content_tag_ids: values.tag ? resolveTagIds({ tag: values.tag }, tagOptions) : payload.content_tag_ids
+  };
+}
+
+function collectSensitiveValues(payload = {}, accessToken = '') {
+  const values = [];
+  if (accessToken) {
+    values.push(String(accessToken));
+  }
+  for (const [key, value] of Object.entries(payload || {})) {
+    if (!SENSITIVE_PAYLOAD_FIELDS.has(key) || value === undefined || value === null || value === '') {
+      continue;
+    }
+    values.push(String(value));
+  }
+  return values;
+}
+
+function unwrapResponseBody(body) {
+  return body?.data && typeof body.data === 'object' ? body.data : body;
+}
+
+function getRejectMessage(body) {
+  const data = unwrapResponseBody(body);
+  return data?.result?.message
+    || data?.result?.errorMessage
+    || data?.message
+    || data?.msg
+    || body?.result?.message
+    || body?.result?.errorMessage
+    || body?.message
+    || body?.msg
+    || '提交被拒绝';
+}
+
+function isRejectedBody(body) {
+  const data = unwrapResponseBody(body);
+  if (
+    body?.result?.success === false
+    || body?.success === false
+    || data?.result?.success === false
+    || data?.success === false
+  ) {
+    return true;
+  }
+  const codes = [
+    body?.code,
+    body?.result?.code,
+    data?.code,
+    data?.result?.code
+  ].filter((code) => code !== undefined && code !== null && code !== '');
+
+  return codes.some((code) => code !== 0 && code !== '0' && code !== 'OK');
+}
+
+export async function submitSkillVersion(payload, options = {}) {
+  const apiBase = options.apiBase || resolveApiBase(options.flags || {});
+  const fetchImpl = options.fetchImpl || compatibleFetch;
+  const sensitiveValues = collectSensitiveValues(payload, options.accessToken);
+  let response;
+
+  try {
+    response = await fetchImpl(`${apiBase}${PATHS.SUBMIT_SKILL_VERSION}`, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${options.accessToken}`,
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch (error) {
+    throw new SkillhubUploadError(
+      'SUBMIT_FAILED',
+      redactMessage(`提交失败: ${error?.message || String(error)}`, sensitiveValues),
+      ExitCodes.SUBMIT_FAILED
+    );
+  }
+
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new SkillhubUploadError(
+      'SUBMIT_FAILED',
+      redactMessage(`提交失败: 响应解析失败`, sensitiveValues),
+      ExitCodes.SUBMIT_FAILED
+    );
+  }
+
+  if (!response.ok) {
+    throw new SkillhubUploadError(
+      'SUBMIT_FAILED',
+      redactMessage(`提交失败: HTTP ${response.status}`, sensitiveValues),
+      ExitCodes.SUBMIT_FAILED
+    );
+  }
+
+  if (isRejectedBody(body)) {
+    throw new SkillhubUploadError(
+      'SUBMIT_REJECTED',
+      redactMessage(getRejectMessage(body), sensitiveValues),
+      ExitCodes.SUBMIT_REJECTED
+    );
+  }
+
+  return unwrapResponseBody(body);
+}

package/cli/tags.mjs

@@ -0,0 +1,149 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  CONTENT_TAG_CACHE_TTL_MS,
+  CONTENT_TAG_FETCH_TIMEOUT_MS,
+  CONTENT_TAG_MATERIAL_ID,
+  CONTENT_TAG_MODULE_ID,
+  PATHS,
+  getContentTagCachePath,
+  getHomeDir,
+  resolveApiBase
+} from './config.mjs';
+import { compatibleFetch } from './fetch.mjs';
+
+export const FALLBACK_CONTENT_TAGS = Object.freeze([
+  Object.freeze({ tagId: '1001', name: '效率工具' }),
+  Object.freeze({ tagId: '1002', name: '内容创作' }),
+  Object.freeze({ tagId: '1003', name: '学习成长' }),
+  Object.freeze({ tagId: '1004', name: '职场办公' }),
+  Object.freeze({ tagId: '1005', name: '编程开发' }),
+  Object.freeze({ tagId: '1006', name: '生活决策' }),
+  Object.freeze({ tagId: '1007', name: '金融理财' }),
+  Object.freeze({ tagId: '1008', name: '其它' })
+]);
+
+function normalizeRemoteTag(raw) {
+  const tagId = String(raw?.tagId ?? raw?.tag_id ?? '').trim();
+  const name = String(raw?.tagName ?? raw?.tag_name ?? raw?.name ?? '').trim();
+  if (!tagId || !name) {
+    return null;
+  }
+  return { tagId, name };
+}
+
+function normalizeRemoteList(data) {
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  const seen = new Set();
+  const list = [];
+  for (const item of data) {
+    const tag = normalizeRemoteTag(item);
+    if (!tag || seen.has(tag.tagId)) {
+      continue;
+    }
+    seen.add(tag.tagId);
+    list.push(tag);
+  }
+  return list;
+}
+
+export async function fetchContentTags({
+  fetchImpl = compatibleFetch,
+  apiBase,
+  signal,
+  flags = {}
+} = {}) {
+  const base = apiBase || resolveApiBase(flags);
+  const url = `${base}${PATHS.QUERY_CONTENT_TAG_CONFIG}?material_id=${CONTENT_TAG_MATERIAL_ID}&module_id=${CONTENT_TAG_MODULE_ID}`;
+  const response = await fetchImpl(url, { method: 'GET', signal });
+  if (!response.ok) {
+    throw new Error(`tag config HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  if (body?.success === false || (body?.code !== undefined && body.code !== 0 && body.code !== '0')) {
+    throw new Error(body?.msg || body?.message || 'tag config rejected');
+  }
+  const list = normalizeRemoteList(body?.data);
+  if (list.length === 0) {
+    throw new Error('tag config returned empty list');
+  }
+  return list;
+}
+
+async function readCachedContentTags(cachePath) {
+  try {
+    const raw = await fs.readFile(cachePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const tags = normalizeRemoteList(parsed?.tags);
+    if (tags.length === 0) {
+      return null;
+    }
+    const fetchedAtMs = Number(parsed?.fetchedAtMs);
+    return { tags, fetchedAtMs: Number.isFinite(fetchedAtMs) ? fetchedAtMs : 0 };
+  } catch {
+    return null;
+  }
+}
+
+async function writeCachedContentTags(cachePath, tags, nowMs) {
+  try {
+    await fs.mkdir(path.dirname(cachePath), { recursive: true });
+    await fs.writeFile(
+      cachePath,
+      JSON.stringify({ fetchedAtMs: nowMs, tags }, null, 2),
+      'utf8'
+    );
+  } catch (error) {
+    // best-effort cache write; do not break main flow
+    process.stderr.write(`[redskillhub-upload] warn: cache write failed: ${error?.message || error}\n`);
+  }
+}
+
+function withTimeout(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return { signal: undefined, cancel: () => {} };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error(`tag config fetch timed out after ${timeoutMs}ms`)), timeoutMs);
+  return { signal: controller.signal, cancel: () => clearTimeout(timer) };
+}
+
+export async function loadContentTags({
+  fetchImpl = compatibleFetch,
+  env = process.env,
+  now = Date.now,
+  flags = {},
+  timeoutMs = CONTENT_TAG_FETCH_TIMEOUT_MS,
+  cacheTtlMs = CONTENT_TAG_CACHE_TTL_MS
+} = {}) {
+  if (env.SKILLHUB_UPLOAD_SKIP_REMOTE_TAGS === '1') {
+    return FALLBACK_CONTENT_TAGS.map((tag) => ({ ...tag }));
+  }
+  const cachePath = getContentTagCachePath(env);
+  const nowMs = typeof now === 'function' ? now() : Number(now) || Date.now();
+  const cached = await readCachedContentTags(cachePath);
+  if (cached && nowMs - cached.fetchedAtMs < cacheTtlMs) {
+    return cached.tags;
+  }
+
+  const { signal, cancel } = withTimeout(timeoutMs);
+  try {
+    const tags = await fetchContentTags({ fetchImpl, flags, signal });
+    cancel();
+    await writeCachedContentTags(cachePath, tags, nowMs);
+    return tags;
+  } catch (error) {
+    cancel();
+    process.stderr.write(`[redskillhub-upload] warn: load content tags failed: ${error?.message || error}\n`);
+    if (cached?.tags?.length) {
+      return cached.tags;
+    }
+    return FALLBACK_CONTENT_TAGS.map((tag) => ({ ...tag }));
+  }
+}
+
+export function getContentTagsHomeDir(env = process.env) {
+  return getHomeDir(env);
+}

package/cli/upload.mjs

@@ -0,0 +1,214 @@
+import { resolveApiBase, PATHS } from './config.mjs';
+import { ExitCodes, SkillhubUploadError } from './errors.mjs';
+import { compatibleFetch } from './fetch.mjs';
+import { redactMessage } from './redact.mjs';
+import { writeUploadProgress } from './output.mjs';
+const SLICE_SIZE = 1024 * 1024;
+
+function firstPresent(...values) {
+  return values.find((value) => value !== undefined && value !== null && value !== '');
+}
+
+function resolvePermitFields(permit = {}) {
+  return {
+    fileId: firstPresent(permit.fileId, permit.fileIds?.[0], permit.file_id, permit.file_ids?.[0]),
+    bucket: firstPresent(permit.bucket, permit.Bucket),
+    region: firstPresent(permit.region, permit.Region),
+    uploadAddr: firstPresent(permit.uploadAddr, permit.upload_addr, permit.Domain),
+    secretId: firstPresent(permit.secretId, permit.tmpSecretId, permit.tmp_secret_id, permit.TmpSecretId, permit.secret?.secretId),
+    secretKey: firstPresent(permit.secretKey, permit.tmpSecretKey, permit.tmp_secret_key, permit.TmpSecretKey, permit.secret?.secretKey),
+    token: firstPresent(permit.token, permit.securityToken, permit.security_token, permit.SecurityToken, permit.secret?.token),
+    expireTime: firstPresent(permit.expireTime, permit.expire_time, permit.expiredTime, permit.expired_time, permit.ExpiredTime)
+  };
+}
+
+function collectSensitiveValues(...items) {
+  return items
+    .flatMap((item) => {
+      if (!item) return [];
+      if (typeof item === 'string') return [item];
+      const fields = resolvePermitFields(item);
+      return [
+        item.accessToken,
+        fields.secretId,
+        fields.secretKey,
+        fields.token
+      ];
+    })
+    .filter((value) => typeof value === 'string' && value.length > 0);
+}
+
+function buildPermitError(message) {
+  return new SkillhubUploadError('PERMIT_FAILED', message, ExitCodes.PERMIT_FAILED);
+}
+
+function isRosSelfBuiltChannel(fields) {
+  return fields.bucket === 'unknown';
+}
+
+function validatePermit(permit) {
+  const fields = resolvePermitFields(permit);
+  const ros = isRosSelfBuiltChannel(fields);
+  const requiredFields = ros
+    ? ['fileId', 'bucket', 'region', 'uploadAddr', 'token']
+    : ['fileId', 'bucket', 'region', 'uploadAddr', 'secretId', 'secretKey', 'token'];
+  const missing = requiredFields.find((key) => !fields[key]);
+  if (missing) {
+    throw buildPermitError(`上传授权字段不完整 (${missing})`);
+  }
+
+  return fields;
+}
+
+function unwrapResponseBody(body) {
+  return body?.data && typeof body.data === 'object' ? body.data : body;
+}
+
+function resolvePermits(token = {}) {
+  const data = unwrapResponseBody(token);
+  return data.uploadTempPermits || data.upload_temp_permits || data.permits || [];
+}
+
+async function defaultUploadFile(cos, params) {
+  await new Promise((resolve, reject) => {
+    cos.uploadFile(params, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+async function createDefaultCos(options) {
+  const { default: COS } = await import('cos-nodejs-sdk-v5');
+  return new COS(options);
+}
+
+function buildCosUploadError(error, sensitiveValues) {
+  return new SkillhubUploadError(
+    'COS_UPLOAD_FAILED',
+    `COS 上传失败: ${redactMessage(error?.message || String(error), sensitiveValues)}`,
+    ExitCodes.COS_UPLOAD_FAILED
+  );
+}
+
+export async function requestUploadToken({ apiBase, accessToken, fetchImpl = compatibleFetch }) {
+  const url = new URL(PATHS.UPLOAD_TOKEN, apiBase);
+  url.searchParams.set('biz_name', 'spectrum');
+  url.searchParams.set('scene', 'skill');
+  url.searchParams.set('file_count', '1');
+  url.searchParams.set('file_format', 'zip');
+  url.searchParams.set('version', '1');
+  url.searchParams.set('source', 'web');
+
+  try {
+    const response = await fetchImpl(url, {
+      headers: { authorization: `Bearer ${accessToken}` }
+    });
+
+    if (!response.ok) {
+      throw buildPermitError(`获取上传授权失败: HTTP ${response.status}`);
+    }
+
+    return unwrapResponseBody(await response.json());
+  } catch (error) {
+    if (error instanceof SkillhubUploadError) {
+      throw error;
+    }
+    throw buildPermitError(`获取上传授权失败: ${redactMessage(error?.message || String(error), [accessToken])}`);
+  }
+}
+
+const ROS_SELF_BUILT_APP_ID = '1251524319';
+
+export async function uploadWithPermit(permit, zipPath, options = {}) {
+  const fields = validatePermit(permit);
+  const ros = isRosSelfBuiltChannel(fields);
+  const uploadFileImpl = options.uploadFileImpl;
+  const cosFactory = options.cosFactory || createDefaultCos;
+
+  const cosInit = {
+    Domain: fields.uploadAddr,
+    getAuthorization: (_, callback) => callback({
+      TmpSecretId: fields.secretId || 'null',
+      TmpSecretKey: fields.secretKey || 'null',
+      SecurityToken: fields.token,
+      StartTime: Math.floor(Date.now() / 1000),
+      ExpiredTime: fields.expireTime ? Math.floor(Number(fields.expireTime) / 1000) : undefined
+    })
+  };
+  if (ros) {
+    cosInit.AppId = ROS_SELF_BUILT_APP_ID;
+  }
+  const cos = uploadFileImpl ? null : await cosFactory(cosInit);
+
+  const params = {
+    Bucket: fields.bucket,
+    Region: fields.region,
+    Key: fields.fileId,
+    FilePath: zipPath,
+    SliceSize: SLICE_SIZE,
+    onProgress: (event = {}) => {
+      const percent = Math.floor(Number(event.percent || 0) * 100);
+      writeUploadProgress(percent, options.progressStream || process.stdout);
+    }
+  };
+
+  try {
+    if (uploadFileImpl) {
+      await uploadFileImpl(params, { permit, fields });
+    } else {
+      await defaultUploadFile(cos, params);
+    }
+  } catch (error) {
+    throw buildCosUploadError(error, collectSensitiveValues(permit));
+  }
+
+  return fields.fileId;
+}
+
+export async function uploadBundle(bundle, options = {}) {
+  if (options.dryRun) {
+    return {
+      bundleFileId: 'dry-run-bundle-file-id',
+      bundleSha256: bundle.bundleSha256,
+      bundleSizeBytes: bundle.bundleSizeBytes,
+      uploaded: false
+    };
+  }
+
+  const apiBase = options.apiBase || resolveApiBase(options.flags || {});
+  const token = await requestUploadToken({
+    apiBase,
+    accessToken: options.accessToken,
+    fetchImpl: options.fetchImpl || compatibleFetch
+  });
+  const permits = [...resolvePermits(token)].sort((a, b) => Number(b.qos || 0) - Number(a.qos || 0));
+
+  if (permits.length === 0) {
+    throw new SkillhubUploadError('COS_UPLOAD_FAILED', '没有可用上传授权', ExitCodes.COS_UPLOAD_FAILED);
+  }
+
+  let lastError;
+  for (const permit of permits) {
+    try {
+      const fileId = await uploadWithPermit(permit, bundle.zipPath, {
+        cosFactory: options.cosFactory,
+        uploadFileImpl: options.uploadFileImpl,
+        progressStream: options.progressStream
+      });
+      return {
+        bundleFileId: fileId,
+        bundleSha256: bundle.bundleSha256,
+        bundleSizeBytes: bundle.bundleSizeBytes,
+        uploaded: true
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw buildCosUploadError(lastError, [
+    options.accessToken,
+    ...collectSensitiveValues(...permits)
+  ]);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "redskillhub-upload",
+  "version": "1.0.0-alpha.1",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "redskillhub-upload": "cli/index.mjs"
+  },
+  "files": [
+    "cli/",
+    "skill/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "dry-run": "node cli/index.mjs publish test/fixtures/minimal-skill --dry-run --agent --yes"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "cos-nodejs-sdk-v5": "^2.14.7",
+    "qrcode": "^1.5.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}