@lingjingai/lj-awb-cli-pre 0.3.15

package/packages/awb-core/src/common.js

@@ -0,0 +1,508 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+export const DEFAULT_API_ORIGIN = 'https://animeworkbench-pre.lingjingai.cn';
+export const API_ORIGIN = (
+  process.env.LINGJING_AWB_API_ORIGIN
+  || process.env.ANIME_API_ORIGIN
+  || process.env.AWB_BASE_URL
+  || DEFAULT_API_ORIGIN
+).replace(/\/+$/, '');
+export const APP_HOME_DIR = process.env.LINGJING_AWB_STATE_DIR || process.env.ANIME_STATE_DIR || path.join(os.homedir(), '.lingjingai', 'awb');
+export const AUTH_PATH = process.env.LINGJING_AWB_AUTH_PATH || process.env.ANIME_AUTH_PATH || path.join(APP_HOME_DIR, 'auth.json');
+export const STATE_PATH = process.env.LINGJING_AWB_STATE_PATH || process.env.ANIME_STATE_PATH || path.join(APP_HOME_DIR, 'state.json');
+export const ACCESS_KEY_ENV_NAMES = ['LINGJING_AWB_ACCESS_KEY', 'AWB_ACCESS_KEY', 'AWB_CODE', 'ANIME_ACCESS_KEY'];
+export const TASK_UPLOAD_SCENE = {
+  IMAGE_CREATE: 'material-image-draw',
+  IMAGE_EDIT: 'material-image-edit',
+  VIDEO_CREATE: 'material-video-create',
+  VIDEO_GROUP: 'material-video-create',
+  SUBJECT: 'material-video-create',
+  DEFAULT: 'material-image-edit',
+};
+export const TERMINAL_TASK_STATES = new Set([
+  'SUCCESS',
+  'COMPLETED',
+  'DONE',
+  'SUCCEEDED',
+  'FAIL',
+  'FAILED',
+  'ERROR',
+  'CANCEL',
+  'CANCELED',
+  'CANCELLED',
+  'TIMEOUT',
+]);
+export const SUCCESS_TASK_STATES = new Set(['SUCCESS', 'COMPLETED', 'DONE', 'SUCCEEDED']);
+
+function parseDotenvValue(value) {
+  let text = String(value ?? '').trim();
+  if (text.length >= 2 && text[0] === text.at(-1) && ['"', "'"].includes(text[0])) {
+    const quote = text[0];
+    text = text.slice(1, -1);
+    if (quote === '"') {
+      text = text
+        .replaceAll('\\n', '\n')
+        .replaceAll('\\r', '\r')
+        .replaceAll('\\t', '\t')
+        .replaceAll('\\"', '"')
+        .replaceAll('\\\\', '\\');
+    }
+  }
+  return text;
+}
+
+function loadDotenvFile(envPath, options = {}) {
+  if (!envPath || !fsSync.existsSync(envPath)) return false;
+  const allowKey = options.allowKey ?? (() => true);
+  let loaded = false;
+  try {
+    for (const rawLine of fsSync.readFileSync(envPath, 'utf8').split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith('#') || !line.includes('=')) continue;
+      const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (!match) continue;
+      const [, key, rawValue] = match;
+      if (!allowKey(key)) continue;
+      if (process.env[key] === undefined) {
+        process.env[key] = parseDotenvValue(rawValue);
+        loaded = true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return loaded;
+}
+
+function loadNearestDotenv() {
+  if (
+    process.env.LINGJING_AWB_DISABLE_DOTENV === '1'
+    || process.env.LINGJING_AWB_DISABLE_DOTENV === 'true'
+    || process.env.ANIME_DISABLE_DOTENV === '1'
+    || process.env.ANIME_DISABLE_DOTENV === 'true'
+  ) return;
+  const configuredEnvPath = process.env.LINGJING_AWB_ENV_PATH || process.env.ANIME_ENV_PATH;
+  let envPath = configuredEnvPath ? path.resolve(configuredEnvPath) : null;
+  if (!envPath) {
+    let current = process.cwd();
+    while (current) {
+      const candidate = path.join(current, '.env');
+      if (fsSync.existsSync(candidate)) {
+        envPath = candidate;
+        break;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  loadDotenvFile(envPath);
+}
+
+function loadUserEnvFiles() {
+  if (
+    process.env.LINGJING_AWB_DISABLE_USER_ENV === '1'
+    || process.env.LINGJING_AWB_DISABLE_USER_ENV === 'true'
+    || process.env.ANIME_DISABLE_USER_ENV === '1'
+    || process.env.ANIME_DISABLE_USER_ENV === 'true'
+  ) return;
+  const allowKey = (key) => /^LINGJING_AWB_/i.test(key) || /^ANIME_/i.test(key) || /^AWB_/i.test(key);
+  for (const filePath of [
+    path.join(os.homedir(), '.lj-awb.env'),
+    path.join(os.homedir(), '.anime.env'),
+    path.join(os.homedir(), '.awb.env'),
+    path.join(os.homedir(), '.zshenv'),
+    path.join(os.homedir(), '.zprofile'),
+    path.join(os.homedir(), '.zshrc'),
+    path.join(os.homedir(), '.profile'),
+    path.join(os.homedir(), '.bash_profile'),
+    path.join(os.homedir(), '.bashrc'),
+  ]) {
+    loadDotenvFile(filePath, { allowKey });
+  }
+}
+
+loadNearestDotenv();
+loadUserEnvFiles();
+
+export async function ensureParent(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+export async function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+export async function writeJson(filePath, value, options = {}) {
+  await ensureParent(filePath);
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  if (options.secure) {
+    await fs.chmod(filePath, 0o600).catch(() => {});
+  }
+}
+
+export async function loadState() {
+  return await readJson(STATE_PATH, {});
+}
+
+export async function saveState(value) {
+  const current = await loadState();
+  const next = {
+    ...current,
+    ...value,
+    updatedAt: Date.now(),
+    updatedAtText: nowIso(),
+  };
+  await writeJson(STATE_PATH, next);
+  return next;
+}
+
+export function trimSecret(value) {
+  const text = String(value ?? '').trim();
+  return text || null;
+}
+
+export function resolveRuntimeAccessKey(auth = null) {
+  for (const envName of ACCESS_KEY_ENV_NAMES) {
+    const accessKey = trimSecret(process.env[envName]);
+    if (accessKey) {
+      return { accessKey, source: 'env', sourceName: envName };
+    }
+  }
+  const saved = trimSecret(auth?.accessKey || auth?.awbCode || auth?.awb_code || auth?.access_key);
+  if (saved) {
+    return { accessKey: saved, source: 'saved', sourceName: 'auth' };
+  }
+  return null;
+}
+
+export function maskSecret(value) {
+  const text = trimSecret(value);
+  if (!text) return null;
+  if (text.length <= 8) return `${'*'.repeat(Math.max(0, text.length - 2))}${text.slice(-2)}`;
+  return `${text.slice(0, 4)}...${text.slice(-4)}`;
+}
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function trimToNull(value) {
+  const text = String(value ?? '').trim();
+  return text || null;
+}
+
+export function toBool(value) {
+  if (value === true || value === 1) return true;
+  if (value == null) return false;
+  return ['true', '1', 'yes', 'y', 'on'].includes(String(value).trim().toLowerCase());
+}
+
+export function toInt(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+export function toNumberOrNull(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+export function parseJsonArg(value, fallback = undefined) {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value !== 'string') return value;
+  return JSON.parse(value);
+}
+
+export function splitCsv(value) {
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  return String(value ?? '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function parseListArg(value) {
+  if (value === undefined || value === null || value === '') return [];
+  if (Array.isArray(value)) return value.flatMap((item) => parseListArg(item));
+  const text = String(value).trim();
+  if (!text) return [];
+  if (text.startsWith('[')) {
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed.map((item) => String(item).trim()).filter(Boolean) : [];
+  }
+  return splitCsv(text);
+}
+
+export function firstArray(value) {
+  if (Array.isArray(value)) return value;
+  if (!value || typeof value !== 'object') return [];
+  for (const nested of Object.values(value)) {
+    const found = firstArray(nested);
+    if (found.length) return found;
+  }
+  return [];
+}
+
+export function flattenRecord(record, prefix = '', out = {}) {
+  if (record == null) return out;
+  if (typeof record !== 'object' || Array.isArray(record)) {
+    out[prefix || 'value'] = record;
+    return out;
+  }
+  for (const [key, value] of Object.entries(record)) {
+    const nextKey = prefix ? `${prefix}_${key}` : key;
+    if (value == null) {
+      out[nextKey] = value;
+    } else if (Array.isArray(value)) {
+      out[nextKey] = JSON.stringify(value);
+    } else if (typeof value === 'object') {
+      flattenRecord(value, nextKey, out);
+    } else {
+      out[nextKey] = value;
+    }
+  }
+  return out;
+}
+
+export function uniqueNonEmpty(values) {
+  return [...new Set((Array.isArray(values) ? values : [])
+    .map((item) => String(item ?? '').trim())
+    .filter(Boolean))];
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function normalizeFeedTaskType(value) {
+  const text = String(value || '').trim().toUpperCase();
+  if (!text) return 'IMAGE_CREATE';
+  if (text === 'VIDEO_CREATE') return 'VIDEO_GROUP';
+  return text;
+}
+
+export function taskStatusText(value) {
+  return String(value ?? '').trim().toUpperCase();
+}
+
+export function isTerminalTaskStatus(value) {
+  return TERMINAL_TASK_STATES.has(taskStatusText(value));
+}
+
+export function isSuccessTaskStatus(value) {
+  return SUCCESS_TASK_STATES.has(taskStatusText(value));
+}
+
+export function taskTypeToStatusKind(taskType) {
+  const normalized = normalizeFeedTaskType(taskType);
+  return normalized.startsWith('VIDEO') ? 'video' : 'image';
+}
+
+export function guessMimeType(filePath) {
+  const ext = path.extname(String(filePath ?? '')).toLowerCase();
+  switch (ext) {
+    case '.bmp':
+      return 'image/bmp';
+    case '.png':
+      return 'image/png';
+    case '.jpg':
+    case '.jpeg':
+      return 'image/jpeg';
+    case '.webp':
+      return 'image/webp';
+    case '.gif':
+      return 'image/gif';
+    case '.mp3':
+      return 'audio/mpeg';
+    case '.wav':
+      return 'audio/wav';
+    case '.m4a':
+      return 'audio/mp4';
+    case '.mp4':
+      return 'video/mp4';
+    case '.mov':
+      return 'video/quicktime';
+    default:
+      return 'application/octet-stream';
+  }
+}
+
+export function safeFileName(filePath) {
+  return path
+    .basename(String(filePath || 'upload.bin'))
+    .replace(/[^0-9A-Za-z._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '') || 'upload.bin';
+}
+
+function parsePngSize(buffer) {
+  const signature = '89504e470d0a1a0a';
+  if (buffer.length < 24 || buffer.subarray(0, 8).toString('hex') !== signature) return null;
+  return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20), format: 'png' };
+}
+
+function parseJpegSize(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) return null;
+  let offset = 2;
+  while (offset + 9 < buffer.length) {
+    if (buffer[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    const size = buffer.readUInt16BE(offset + 2);
+    if ((marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf)) {
+      return { width: buffer.readUInt16BE(offset + 7), height: buffer.readUInt16BE(offset + 5), format: 'jpeg' };
+    }
+    offset += 2 + size;
+  }
+  return null;
+}
+
+function parseWebpSize(buffer) {
+  if (buffer.length < 30) return null;
+  if (buffer.subarray(0, 4).toString('ascii') !== 'RIFF') return null;
+  if (buffer.subarray(8, 12).toString('ascii') !== 'WEBP') return null;
+  const chunkType = buffer.subarray(12, 16).toString('ascii');
+  if (chunkType === 'VP8 ') {
+    return { width: buffer.readUInt16LE(26) & 0x3fff, height: buffer.readUInt16LE(28) & 0x3fff, format: 'webp' };
+  }
+  if (chunkType === 'VP8L') {
+    const bits = buffer.readUInt32LE(21);
+    return { width: (bits & 0x3fff) + 1, height: ((bits >> 14) & 0x3fff) + 1, format: 'webp' };
+  }
+  if (chunkType === 'VP8X') {
+    return { width: 1 + buffer.readUIntLE(24, 3), height: 1 + buffer.readUIntLE(27, 3), format: 'webp' };
+  }
+  return null;
+}
+
+export async function inspectLocalFile(filePath) {
+  const absolutePath = path.resolve(String(filePath));
+  const stat = await fs.stat(absolutePath).catch((error) => {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  });
+  const mimeType = guessMimeType(absolutePath);
+  if (!stat) {
+    return {
+      filePath: absolutePath,
+      fileName: path.basename(absolutePath),
+      exists: false,
+      size: null,
+      mimeType,
+      width: null,
+      height: null,
+    };
+  }
+  let meta = null;
+  if (mimeType.startsWith('image/')) {
+    const buffer = await fs.readFile(absolutePath).catch(() => null);
+    meta = buffer ? parsePngSize(buffer) ?? parseJpegSize(buffer) ?? parseWebpSize(buffer) : null;
+  }
+  return {
+    filePath: absolutePath,
+    fileName: path.basename(absolutePath),
+    exists: true,
+    size: stat.size,
+    mimeType,
+    width: meta?.width ?? null,
+    height: meta?.height ?? null,
+    format: meta?.format ?? null,
+  };
+}
+
+export async function inspectLocalFiles(filePaths) {
+  const result = [];
+  for (const filePath of parseListArg(filePaths)) {
+    result.push(await inspectLocalFile(filePath));
+  }
+  return result;
+}
+
+function sha1(input, encoding = 'hex') {
+  return crypto.createHash('sha1').update(input).digest(encoding);
+}
+
+function hmacSha1(key, input, encoding = 'hex') {
+  return crypto.createHmac('sha1', key).update(input).digest(encoding);
+}
+
+function encodeCosValue(value) {
+  return encodeURIComponent(String(value)).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+export function encodeObjectNamePath(value) {
+  return String(value ?? '')
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+}
+
+export function buildCosAuthorization({
+  secretKey,
+  secretId,
+  method,
+  objectName,
+  contentLength,
+  host,
+  startTime,
+  expiredTime,
+}) {
+  const signTime = `${startTime};${expiredTime}`;
+  const signKey = hmacSha1(secretKey, signTime);
+  const httpString = [
+    method.toLowerCase(),
+    `/${objectName}`,
+    '',
+    `content-length=${encodeCosValue(contentLength)}&host=${encodeCosValue(host)}`,
+    '',
+  ].join('\n');
+  const stringToSign = ['sha1', signTime, sha1(httpString), ''].join('\n');
+  const signature = hmacSha1(signKey, stringToSign);
+  return [
+    'q-sign-algorithm=sha1',
+    `q-ak=${secretId}`,
+    `q-sign-time=${signTime}`,
+    `q-key-time=${signTime}`,
+    'q-header-list=content-length;host',
+    'q-url-param-list=',
+    `q-signature=${signature}`,
+  ].join('&');
+}
+
+export class LingjingAwbCliError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'LingjingAwbCliError';
+    this.type = options.type || 'error';
+    this.exitCode = options.exitCode || 1;
+    this.hint = options.hint || '';
+    this.details = options.details || null;
+  }
+}
+
+export function createEnvelope({ status = 'success', data = null, error = null, meta = {} } = {}) {
+  const { elapsedMs, ...restMeta } = meta;
+  const success = status === 'success';
+  return {
+    status,
+    ...(success ? { data } : { error }),
+    meta: {
+      command: meta.command || '',
+      elapsed_ms: elapsedMs ?? null,
+      api_origin: API_ORIGIN,
+      ...restMeta,
+    },
+  };
+}