redskillhub-upload 1.0.0-alpha.1

package/cli/fetch.mjs

@@ -0,0 +1,127 @@
+import http from 'node:http';
+import https from 'node:https';
+import tls from 'node:tls';
+import { DEFAULT_API_BASE } from './config.mjs';
+
+const DEFAULT_API_HOST = new URL(DEFAULT_API_BASE).hostname;
+const BETA_WILDCARD_SAN = 'DNS:*.beta.xiaohongshu.com';
+
+function resolveUrl(input) {
+  if (input instanceof URL) {
+    return input;
+  }
+  if (input?.url) {
+    return new URL(input.url);
+  }
+  return new URL(String(input));
+}
+
+function resolveErrorCode(error) {
+  return error?.code || error?.cause?.code;
+}
+
+export function isDefaultBetaApiAltNameError(input, error) {
+  try {
+    const url = resolveUrl(input);
+    return url.protocol === 'https:'
+      && url.hostname === DEFAULT_API_HOST
+      && resolveErrorCode(error) === 'ERR_TLS_CERT_ALTNAME_INVALID';
+  } catch {
+    return false;
+  }
+}
+
+export function checkDefaultBetaApiServerIdentity(host, cert) {
+  const error = tls.checkServerIdentity(host, cert);
+  if (!error) {
+    return undefined;
+  }
+  if (
+    host === DEFAULT_API_HOST
+    && error.code === 'ERR_TLS_CERT_ALTNAME_INVALID'
+    && String(cert?.subjectaltname || '').includes(BETA_WILDCARD_SAN)
+  ) {
+    return undefined;
+  }
+  return error;
+}
+
+function normalizeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (typeof headers.forEach === 'function') {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+
+class NodeFetchResponse {
+  constructor(statusCode, headers, body) {
+    this.status = statusCode || 0;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.headers = headers;
+    this.body = body;
+  }
+
+  async text() {
+    return this.body.toString('utf8');
+  }
+
+  async json() {
+    return JSON.parse(await this.text());
+  }
+}
+
+export function nodeRequestFetch(input, init = {}) {
+  const url = resolveUrl(input);
+  const transport = url.protocol === 'http:' ? http : https;
+  const options = {
+    method: init.method || 'GET',
+    headers: normalizeHeaders(init.headers)
+  };
+  if (url.protocol === 'https:' && url.hostname === DEFAULT_API_HOST) {
+    options.checkServerIdentity = checkDefaultBetaApiServerIdentity;
+  }
+
+  return new Promise((resolve, reject) => {
+    const req = transport.request(url, options, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        resolve(new NodeFetchResponse(res.statusCode, res.headers, Buffer.concat(chunks)));
+      });
+    });
+    req.on('error', reject);
+    if (init.body === undefined || init.body === null) {
+      req.end();
+      return;
+    }
+    req.end(init.body);
+  });
+}
+
+export function createCompatibleFetch({
+  primaryFetch = fetch,
+  fallbackFetch = nodeRequestFetch
+} = {}) {
+  return async function compatibleFetch(input, init) {
+    try {
+      return await primaryFetch(input, init);
+    } catch (error) {
+      if (!isDefaultBetaApiAltNameError(input, error)) {
+        throw error;
+      }
+      return fallbackFetch(input, init);
+    }
+  };
+}
+
+export const compatibleFetch = createCompatibleFetch();

package/cli/index.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { writeResult } from './output.mjs';
+import { ExitCodes, SkillhubUploadError, toResultError } from './errors.mjs';
+import { prepareBundle } from './pack.mjs';
+import {
+  applyConfirmEdit,
+  buildDraftPayload,
+  formatContentTagOptions,
+  submitSkillVersion
+} from './submit.mjs';
+import { uploadBundle } from './upload.mjs';
+import { askAgent, confirmAgent, createPromptSession } from './prompt.mjs';
+import { TOKEN_REFRESH_BUFFER_MS } from './config.mjs';
+import { loadContentTags } from './tags.mjs';
+
+function normalizeFlagName(name) {
+  if (name === 'dry-run') return 'dryRun';
+  if (name === 'api-base') return 'apiBase';
+  return name;
+}
+
+function setFlag(flags, rawName, value) {
+  const name = normalizeFlagName(rawName);
+  if (Object.prototype.hasOwnProperty.call(flags, name)) {
+    flags[name] = Array.isArray(flags[name]) ? [...flags[name], value] : [flags[name], value];
+    return;
+  }
+  flags[name] = value;
+}
+
+export function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  let pathArg;
+  const flags = {};
+  for (let i = 0; i < rest.length; i += 1) {
+    const item = rest[i];
+    if (item === '--dry-run') flags.dryRun = true;
+    else if (item === '--agent') flags.agent = true;
+    else if (item === '--yes') flags.yes = true;
+    else if (item.startsWith('--') && item.includes('=')) {
+      const equalIndex = item.indexOf('=');
+      setFlag(flags, item.slice(2, equalIndex), item.slice(equalIndex + 1));
+    } else if (item.startsWith('--')) setFlag(flags, item.slice(2), rest[++i] || true);
+    else if (!pathArg) pathArg = item;
+  }
+  return { command, pathArg, flags };
+}
+
+function buildValidatedDraftPayload(input) {
+  try {
+    return buildDraftPayload(input);
+  } catch (error) {
+    if (error instanceof SkillhubUploadError) {
+      throw error;
+    }
+    throw new SkillhubUploadError(
+      'LOCAL_VALIDATION_FAILED',
+      error?.message || String(error),
+      ExitCodes.LOCAL_VALIDATION
+    );
+  }
+}
+
+function wrapLocalValidation(error) {
+  if (error instanceof SkillhubUploadError) {
+    return error;
+  }
+  return new SkillhubUploadError(
+    'LOCAL_VALIDATION_FAILED',
+    error?.message || String(error),
+    ExitCodes.LOCAL_VALIDATION
+  );
+}
+
+function assertUsableCredentials(credentials, nowMs = Date.now()) {
+  if (!credentials?.accessToken) {
+    throw new SkillhubUploadError('NEED_LOGIN', '请先执行 redskillhub-upload login', ExitCodes.NEED_LOGIN);
+  }
+
+  const expireTimeMs = Number(credentials.expireTimeMs || 0);
+  if (!Number.isFinite(expireTimeMs) || expireTimeMs <= nowMs + TOKEN_REFRESH_BUFFER_MS) {
+    throw new SkillhubUploadError('NEED_LOGIN', '登录已过期，请重新执行 redskillhub-upload login', ExitCodes.NEED_LOGIN);
+  }
+}
+
+export async function ensurePublishCredentials({
+  flags = {},
+  env = process.env,
+  io = {},
+  nowMs = Date.now(),
+  readCredentials,
+  login
+}) {
+  let credentials = await readCredentials(env);
+  try {
+    assertUsableCredentials(credentials, nowMs);
+    return credentials;
+  } catch (error) {
+    if (!(error instanceof SkillhubUploadError) || error.code !== 'NEED_LOGIN') {
+      throw error;
+    }
+  }
+
+  await login({
+    flags,
+    env,
+    fetchImpl: io.fetchImpl,
+    sleep: io.sleep,
+    now: io.now,
+    promptStream: io.out || process.stdout
+  });
+  credentials = await readCredentials(env);
+  assertUsableCredentials(credentials, io.now ? io.now() : nowMs);
+  return credentials;
+}
+
+async function confirmBeforeSubmit(payload, io = {}, { tagOptions } = {}) {
+  let current = payload;
+  while (true) {
+    const answer = await confirmAgent(current, io);
+    if (answer.action === 'submit') {
+      return current;
+    }
+    if (answer.action === 'edit') {
+      try {
+        current = applyConfirmEdit(current, answer.values || {}, { tagOptions });
+      } catch (error) {
+        throw wrapLocalValidation(error);
+      }
+      continue;
+    }
+    return null;
+  }
+}
+
+function attachUploadResult(payload, upload) {
+  return {
+    ...payload,
+    bundle_file_id: upload.bundleFileId || '',
+    bundle_sha256: upload.bundleSha256,
+    bundle_size_bytes: upload.bundleSizeBytes
+  };
+}
+
+async function collectPublishFlags(flags, io = {}, { tagOptions = [] } = {}) {
+  const collected = { ...flags };
+  if (!collected.source) {
+    collected.source = await askAgent({
+      type: 'source',
+      options: ['original', 'repost'],
+      message: '请选择内容来源'
+    }, io);
+  }
+
+  if (
+    collected.source === 'repost'
+    && !collected.repostSource
+    && !collected['repost-source']
+  ) {
+    collected.repostSource = await askAgent({
+      type: 'repost_source',
+      message: '请输入转载平台名，15 字符内'
+    }, io);
+  }
+
+  if (!collected.tagId && !collected['tag-id'] && !collected.tag) {
+    collected.tag = await askAgent({
+      type: 'tag',
+      multi: true,
+      options: tagOptions.map((tag) => tag.name),
+      message: `请选择一个或多个内容标签，多个用逗号分隔：${formatContentTagOptions(tagOptions)}`
+    }, io);
+  }
+  return collected;
+}
+
+export async function main(argv = process.argv.slice(2), env = process.env, io = {}) {
+  const { command, pathArg, flags } = parseArgs(argv);
+  const out = io.out || process.stdout;
+  if (!command) {
+    throw new SkillhubUploadError(
+      'INVALID_ARGS',
+      '请指定要执行的操作：login、publish、whoami 或 logout',
+      ExitCodes.INVALID_ARGS
+    );
+  }
+  if (command === 'whoami') {
+    const { readCredentials, maskCredentials } = await import('./auth.mjs');
+    writeResult({ status: 'ok', command, credentials: maskCredentials(await readCredentials(env)) }, out);
+    return;
+  }
+  if (command === 'logout') {
+    const { removeCredentials } = await import('./auth.mjs');
+    await removeCredentials(env);
+    writeResult({ status: 'ok', command }, out);
+    return;
+  }
+  if (command === 'login') {
+    if (flags.cancel) {
+      const { cancelLogin } = await import('./auth.mjs');
+      const cancelled = await cancelLogin(env);
+      writeResult({ status: 'cancelled', command, ...cancelled }, out);
+      return;
+    }
+    const { login } = await import('./auth.mjs');
+    const credentials = await login({
+      flags,
+      env,
+      fetchImpl: io.fetchImpl,
+      sleep: io.sleep,
+      now: io.now,
+      promptStream: out
+    });
+    writeResult({ status: 'ok', command, credentials }, out);
+    return;
+  }
+  if (command === 'publish') {
+    if (!pathArg) {
+      throw new SkillhubUploadError('INVALID_ARGS', '请指定本地 skill 目录路径', ExitCodes.INVALID_ARGS);
+    }
+
+    const dryRun = Boolean(flags.dryRun);
+    let credentials = null;
+    if (!dryRun) {
+      const { readCredentials, login } = await import('./auth.mjs');
+      credentials = await ensurePublishCredentials({
+        flags,
+        env,
+        io: { ...io, out },
+        nowMs: io.now ? io.now() : Date.now(),
+        readCredentials,
+        login
+      });
+    }
+
+    const bundle = await prepareBundle(pathArg, { env });
+    const bundleMetadata = {
+      bundleSha256: bundle.bundleSha256,
+      bundleSizeBytes: bundle.bundleSizeBytes
+    };
+    const tagOptions = await loadContentTags({
+      fetchImpl: io.fetchImpl,
+      env,
+      now: io.now,
+      flags
+    });
+    const promptSession = createPromptSession({
+      input: io.input || process.stdin,
+      out
+    });
+    try {
+      const publishFlags = await collectPublishFlags(flags, promptSession, { tagOptions });
+      const draftPayload = buildValidatedDraftPayload({
+        flags: publishFlags,
+        metadata: bundle.metadata,
+        bundle: bundleMetadata,
+        tagOptions
+      });
+
+      if (dryRun) {
+        const upload = await uploadBundle(bundle, { dryRun: true });
+        writeResult({ status: 'dry_run', payload: attachUploadResult(draftPayload, upload) }, out);
+        return;
+      }
+
+      const confirmedPayload = await confirmBeforeSubmit(draftPayload, promptSession, { tagOptions });
+      if (!confirmedPayload) {
+        writeResult({ status: 'cancelled' }, out);
+        return;
+      }
+
+      const upload = await uploadBundle(bundle, {
+        dryRun: false,
+        flags: publishFlags,
+        accessToken: credentials.accessToken,
+        fetchImpl: io.fetchImpl,
+        cosFactory: io.cosFactory,
+        uploadFileImpl: io.uploadFileImpl,
+        progressStream: io.progressStream || out
+      });
+      const submitted = await submitSkillVersion(attachUploadResult(confirmedPayload, upload), {
+        flags: publishFlags,
+        accessToken: credentials.accessToken,
+        fetchImpl: io.fetchImpl
+      });
+      writeResult({ status: 'submitted', response: submitted }, out);
+      return;
+    } finally {
+      promptSession.close();
+    }
+  }
+  throw new SkillhubUploadError('INVALID_ARGS', `不支持的操作：${command}，可用操作：login、publish、whoami、logout`, ExitCodes.INVALID_ARGS);
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main().catch((error) => {
+    writeResult(toResultError(error), process.stderr);
+    process.exit(error.exitCode || 1);
+  });
+}

package/cli/output.mjs

@@ -0,0 +1,15 @@
+export function writeEvent(prefix, payload, stream = process.stdout) {
+  stream.write(`${prefix}:${JSON.stringify(payload)}\n`);
+}
+
+export function writePrompt(payload, stream = process.stdout) {
+  writeEvent('PROMPT', payload, stream);
+}
+
+export function writeResult(payload, stream = process.stdout) {
+  writeEvent('RESULT_JSON', payload, stream);
+}
+
+export function writeUploadProgress(percent, stream = process.stdout) {
+  stream.write(`UPLOAD_PROGRESS:${percent}\n`);
+}