magic-builder 1.0.0 → 1.1.1

package/README.md

@@ -126,6 +126,31 @@ magic-builder link create --title "Weekly Report"
 magic-builder link create --fid <faas-id>
 ```
 
+Submit Markdown to a People performance draft (`perf` is an alias):
+
+```bash
+magic-builder performance --cookie ./cookie.txt --markdown ./performance.md
+magic-builder perf --cookie "$PEOPLE_COOKIE" --markdown "# Performance summary"
+magic-builder perf --cookie ./cookie.txt --markdown https://example.com/performance.md --dry-run
+```
+
+Cookie input accepts a raw `Cookie` header, a local path, or a Netscape cookie file. Markdown input accepts literal content, a local path, an HTTP(S) URL, or stdin. The command extracts `x-f-csrf` from the Cookie and does not print the Cookie in its output.
+
+When `--cookie` and `--cookie-file` are omitted, `performance` automatically reads `./cookie.txt`, matching the default output of `extract-cookie`:
+
+```bash
+magic-builder extract-cookie --curl-file ./request.curl
+magic-builder performance --markdown ./performance.md
+```
+
+Extract Cookie from a copied curl command. This is a top-level general-purpose command. The default output is `./cookie.txt`; the file is created with mode `0600`:
+
+```bash
+magic-builder extract-cookie --curl-file ./request.curl
+magic-builder extract-cookie --curl "curl 'https://example.com/...' -b 'foo=bar; token=value'"
+cat ./request.curl | magic-builder extract-cookie --out-dir ./secrets
+```
+
 Create or append a Feishu document HTML Box:
 
 ```bash

package/bin/magic-builder.js

@@ -12,6 +12,9 @@ const COMMANDS = {
   link: require('../src/commands/link'),
   doc: require('../src/commands/doc'),
   feedback: require('../src/commands/feedback'),
+  performance: require('../src/commands/performance'),
+  perf: require('../src/commands/performance'),
+  'extract-cookie': require('../src/commands/extract-cookie'),
   skill: require('../src/commands/skill'),
   version: require('../src/commands/version'),
   update: require('../src/commands/update'),

package/package.json

@@ -1,19 +1,30 @@
 {
   "name": "magic-builder",
-  "version": "1.0.0",
-  "description": "CLI for Magic Builder — publish pages, functions, and files",
+  "version": "1.1.1",
+  "description": "CLI for Magic Builder — publish pages, functions, files, and performance drafts",
   "bin": {
-    "magic-builder": "./bin/magic-builder.js",
-    "magic-cli": "./bin/magic-builder.js",
-    "miaobi": "./bin/magic-builder.js"
+    "magic-builder": "bin/magic-builder.js",
+    "magic-cli": "bin/magic-builder.js",
+    "miaobi": "bin/magic-builder.js"
   },
   "main": "./src/index.js",
   "engines": {
     "node": ">=18.0.0"
   },
   "type": "commonjs",
-  "files": ["bin/", "src/", "README.md", "LICENSE"],
-  "keywords": ["magic-builder", "miaobi", "cli", "faas", "publish"],
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "magic-builder",
+    "miaobi",
+    "cli",
+    "faas",
+    "publish"
+  ],
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/src/commands/extract-cookie.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require('fs');
+const { basename, dirname, resolve } = require('path');
+const { success, fail } = require('../lib/output');
+
+function run(args, opts) {
+  if (args.length) fail('Usage: magic-builder extract-cookie --curl <content|file> [--out <file>|--out-dir <dir>]', 'E_INVALID_ARGS');
+  const curl = readCurl(opts.curl, opts.curlFile);
+  if (!curl) fail('Missing curl content. Use --curl <content|file>, --curl-file <file>, or stdin.', 'E_INVALID_ARGS');
+  const cookie = extractCookieFromCurl(curl);
+  if (!cookie) fail('No Cookie found in curl. Expected -b/--cookie or a Cookie request header.', 'E_INVALID_ARGS');
+
+  const output = resolveOutput(opts.out, opts.outDir);
+  mkdirSync(dirname(output), { recursive: true });
+  writeFileSync(output, `${cookie}\n`, { encoding: 'utf8', mode: 0o600 });
+  success({ path: output, filename: basename(output), cookieCount: cookie.split(';').filter(Boolean).length }, opts);
+}
+
+function readCurl(value, file) {
+  const input = String(file || value || '').trim();
+  if (!input && !process.stdin.isTTY) return readFileSync(0, 'utf8');
+  if (!input) return '';
+  const path = resolve(input);
+  return file || existsSync(path) ? readFileSync(path, 'utf8') : input;
+}
+
+function extractCookieFromCurl(curl) {
+  const tokens = tokenizeShell(String(curl || '').replace(/\\\r?\n/g, ' '));
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === '-b' || token === '--cookie') return normalizeCookie(tokens[i + 1] || '');
+    if (token.startsWith('--cookie=')) return normalizeCookie(token.slice('--cookie='.length));
+    if (token === '-H' || token === '--header') {
+      const header = tokens[i + 1] || '';
+      if (/^cookie\s*:/i.test(header)) return normalizeCookie(header);
+    }
+    if (token.startsWith('--header=')) {
+      const header = token.slice('--header='.length);
+      if (/^cookie\s*:/i.test(header)) return normalizeCookie(header);
+    }
+  }
+  return '';
+}
+
+function normalizeCookie(raw) {
+  return String(raw || '').replace(/^cookie\s*:\s*/i, '').trim();
+}
+
+function tokenizeShell(input) {
+  const tokens = [];
+  let token = '';
+  let quote = '';
+  let escaped = false;
+  for (const char of input) {
+    if (escaped) {
+      token += char;
+      escaped = false;
+    } else if (char === '\\' && quote !== "'") {
+      escaped = true;
+    } else if (quote) {
+      if (char === quote) quote = '';
+      else token += char;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      if (token) {
+        tokens.push(token);
+        token = '';
+      }
+    } else {
+      token += char;
+    }
+  }
+  if (escaped) token += '\\';
+  if (token) tokens.push(token);
+  return tokens;
+}
+
+function resolveOutput(out, outDir) {
+  if (out) return resolve(String(out));
+  return resolve(String(outDir || process.cwd()), 'cookie.txt');
+}
+
+module.exports = { run, extractCookieFromCurl, resolveOutput };

package/src/commands/performance.js

@@ -0,0 +1,264 @@
+'use strict';
+
+const { existsSync, readFileSync } = require('fs');
+const { resolve } = require('path');
+const { success, fail } = require('../lib/output');
+
+const DEFAULTS = {
+  endpoint: 'https://people.bytedance.net/perf/api/foundation/v2/draft',
+  reviewId: '7654473253011852917',
+  formId: '7654466592117358592',
+  templateId: '7654466592117358609',
+  unitId: '7654466592117358775',
+  fieldId: '7654466592117358799',
+  textFieldId: '7654466592117358824',
+  operatorId: '6687792427639817740',
+  sourceId: '7784085065561419062',
+  fieldSourceId: '7662587009851985528',
+  rootReviewId: '7657808756893306935',
+  version: 5,
+};
+
+async function run(args, opts) {
+  if (args.length) fail('Usage: magic-builder performance --cookie <content|file> --markdown <content|file|url>', 'E_INVALID_ARGS');
+
+  const cookie = readCookie(opts.cookie, opts.cookieFile);
+  if (!cookie) fail('Missing Cookie. Use --cookie <content|file> or --cookie-file <file>.', 'E_INVALID_ARGS');
+
+  const markdown = await readMarkdown(opts.markdown, opts.markdownFile);
+  if (!markdown.trim()) fail('Missing Markdown. Use --markdown <content|file|url>, --markdown-file <file>, or stdin.', 'E_INVALID_ARGS');
+
+  const csrf = getCookie(cookie, 'x-f-csrf');
+  if (!csrf) fail('Cookie does not contain x-f-csrf.', 'E_INVALID_ARGS');
+
+  const config = resolveConfig(opts);
+  const payload = buildPayload(markdown, config);
+  if (opts.dryRun) {
+    success({ dryRun: true, endpoint: config.endpoint, payload }, opts);
+    return;
+  }
+
+  const response = await fetch(config.endpoint, {
+    method: 'POST',
+    headers: {
+      accept: 'application/json, text/plain, */*',
+      'accept-language': 'zh-CN,zh;q=0.9',
+      'content-type': 'application/json;charset=UTF-8',
+      cookie,
+      origin: 'https://people.bytedance.net',
+      referer: config.referer,
+      'rpc-persist-lane-c-perfx-tenant-id': config.tenantId,
+      'x-f-csrf': csrf,
+      'x-f-lang': 'zh-CN',
+      'x-f-timezone': 'Asia/Shanghai',
+    },
+    body: JSON.stringify(payload),
+  });
+
+  const text = await response.text();
+  const data = parseJson(text);
+  if (!response.ok) {
+    const error = new Error(data?.message || data?.msg || `Performance request failed: HTTP ${response.status}`);
+    error.code = response.status === 401 || response.status === 403 ? 'E_AUTH_FAILED' : 'E_REQUEST_FAILED';
+    throw error;
+  }
+  success(data === null ? text : data, opts);
+}
+
+function readCookie(value, file) {
+  const defaultFile = resolve(process.cwd(), 'cookie.txt');
+  const input = String(file || value || (existsSync(defaultFile) ? defaultFile : '')).trim();
+  if (!input) return '';
+  const path = resolve(input);
+  const raw = file || existsSync(path) ? readFileSync(path, 'utf8') : input;
+  return normalizeCookie(raw);
+}
+
+async function readMarkdown(value, file) {
+  const input = String(file || value || '').trim();
+  if (!input && !process.stdin.isTTY) return readFileSync(0, 'utf8');
+  if (!input) return '';
+  if (!file && /^https?:\/\//i.test(input)) {
+    const response = await fetch(input);
+    if (!response.ok) throw new Error(`Unable to read Markdown URL: HTTP ${response.status}`);
+    return response.text();
+  }
+  const path = resolve(input);
+  return file || existsSync(path) ? readFileSync(path, 'utf8') : input;
+}
+
+function normalizeCookie(raw) {
+  const text = String(raw || '').trim();
+  const cookieHeader = text.match(/^cookie:\s*(.+)$/im);
+  if (cookieHeader) return cookieHeader[1].trim();
+  if (!text.includes('\n')) return text;
+
+  const netscape = text.split(/\r?\n/)
+    .filter(line => line && !line.startsWith('#'))
+    .map(line => line.split('\t'))
+    .filter(parts => parts.length >= 7)
+    .map(parts => `${parts[5]}=${parts[6]}`);
+  if (netscape.length) return netscape.join('; ');
+
+  return text.split(/\r?\n/).map(line => line.trim()).filter(Boolean).join(' ');
+}
+
+function getCookie(cookie, name) {
+  for (const part of cookie.split(';')) {
+    const index = part.indexOf('=');
+    if (index < 0) continue;
+    if (part.slice(0, index).trim().toLowerCase() === name.toLowerCase()) return part.slice(index + 1).trim();
+  }
+  return '';
+}
+
+function resolveConfig(opts) {
+  const reviewId = String(opts.reviewId || DEFAULTS.reviewId);
+  const formId = String(opts.formId || DEFAULTS.formId);
+  const templateId = String(opts.templateId || DEFAULTS.templateId);
+  const tenantId = String(opts.tenantId || getCookie(String(opts.cookie || ''), 'tenant_id') || '6685321562717324807');
+  return {
+    endpoint: String(opts.endpoint || DEFAULTS.endpoint),
+    reviewId,
+    formId,
+    templateId,
+    unitId: String(opts.unitId || DEFAULTS.unitId),
+    fieldId: String(opts.fieldId || DEFAULTS.fieldId),
+    textFieldId: String(opts.textFieldId || DEFAULTS.textFieldId),
+    operatorId: String(opts.operatorId || DEFAULTS.operatorId),
+    sourceId: String(opts.sourceId || DEFAULTS.sourceId),
+    fieldSourceId: String(opts.fieldSourceId || DEFAULTS.fieldSourceId),
+    rootReviewId: String(opts.rootReviewId || DEFAULTS.rootReviewId),
+    version: Number(opts.version || DEFAULTS.version),
+    tenantId,
+    referer: String(opts.referer || `https://people.bytedance.net/performance/perf/review/${reviewId}/${formId}?mode=editable`),
+    uid: String(opts.uid || `magic-builder-${Date.now()}`),
+  };
+}
+
+function buildPayload(markdown, config) {
+  const now = Date.now();
+  const sections = splitMarkdownSections(markdown);
+  const subUnits = sections.map((section, index) => {
+    const value = { '0': { ops: markdownToDelta(section), zoneId: '0', zoneType: 'Z' } };
+    if (index > 0) {
+      return [{
+        key: `${index - 1}-${now + index}-${Math.random()}`,
+        id: config.textFieldId,
+        entityType: 'text',
+        value,
+      }];
+    }
+    return [{
+      id: config.textFieldId,
+      source_id: config.sourceId,
+      value,
+      json_value: {},
+      created_time: now,
+      updated_time: now,
+      entityType: 'text',
+    }];
+  });
+  return {
+    key: `${config.reviewId}__confirm_invitation__${config.operatorId}__${config.formId}`,
+    data: {
+      keyWorks: {
+        valueSetting: [{ operatorId: config.operatorId, source_id: config.sourceId, isReviewee: true }],
+        currentUserId: config.operatorId,
+        units: [{
+          id: config.unitId,
+          fields: [{
+            id: config.fieldId,
+            entityType: 'multiple_texts',
+            source_id: config.fieldSourceId,
+            value: '',
+            created_time: now,
+            updated_time: now,
+            extra: null,
+            json_value: {},
+            sub_units: subUnits,
+          }],
+          type: 'object',
+          unknown: false,
+        }],
+        templateType: 'write',
+        template_id: config.templateId,
+      },
+      rootReviewId: config.rootReviewId,
+      uid: config.uid,
+    },
+    version: config.version,
+  };
+}
+
+function splitMarkdownSections(markdown) {
+  const text = String(markdown || '').replace(/\r\n?/g, '\n').trim();
+  if (!text) return [''];
+  const lines = text.split('\n');
+  const sections = [];
+  let current = [];
+  for (const line of lines) {
+    if (/^##\s+/.test(line)) {
+      if (current.some(item => item.trim()) && !current.every(item => /^#\s+/.test(item) || !item.trim())) {
+        sections.push(current.join('\n').trim());
+      }
+      current = [`# ${line.replace(/^##\s+/, '')}`];
+    } else if (current.length || !/^#\s+/.test(line)) {
+      current.push(line);
+    }
+  }
+  if (current.some(item => item.trim())) sections.push(current.join('\n').trim());
+  return sections.length ? sections : [text];
+}
+
+function markdownToDelta(markdown) {
+  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
+  const ops = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      appendInline(ops, line);
+      ops.push({ insert: '\n', attributes: { 'code-block': true } });
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    const unordered = line.match(/^\s*[-*+]\s+(.+)$/);
+    const ordered = line.match(/^\s*\d+[.)]\s+(.+)$/);
+    const quote = line.match(/^\s*>\s?(.*)$/);
+    const content = heading?.[2] ?? unordered?.[1] ?? ordered?.[1] ?? quote?.[1] ?? line;
+    appendInline(ops, content);
+    const attributes = heading ? { header: heading[1].length }
+      : unordered ? { list: 'bullet' }
+        : ordered ? { list: 'ordered' }
+          : quote ? { blockquote: true }
+            : undefined;
+    ops.push(attributes ? { insert: '\n', attributes } : { insert: '\n' });
+  }
+  if (ops.length > 1 && lines.at(-1) === '') ops.pop();
+  return ops.length ? ops : [{ insert: '\n' }];
+}
+
+function appendInline(ops, text) {
+  const pattern = /(\*\*|__)(.+?)\1|(?<!\*)\*([^*\n]+)\*|(?<!_)_([^_\n]+)_|`([^`\n]+)`|\[([^\]]+)]\((https?:\/\/[^\s)]+)\)/g;
+  let cursor = 0;
+  let match;
+  while ((match = pattern.exec(text))) {
+    if (match.index > cursor) ops.push({ insert: text.slice(cursor, match.index) });
+    if (match[2]) ops.push({ insert: match[2], attributes: { bold: true } });
+    else if (match[3] || match[4]) ops.push({ insert: match[3] || match[4], attributes: { italic: true } });
+    else if (match[5]) ops.push({ insert: match[5], attributes: { code: true } });
+    else ops.push({ insert: match[6], attributes: { link: match[7] } });
+    cursor = pattern.lastIndex;
+  }
+  if (cursor < text.length) ops.push({ insert: text.slice(cursor) });
+}
+
+function parseJson(text) {
+  try { return text ? JSON.parse(text) : {}; } catch (_) { return null; }
+}
+
+module.exports = { run, readCookie, normalizeCookie, getCookie, splitMarkdownSections, markdownToDelta, buildPayload };

package/src/index.js

@@ -13,6 +13,9 @@ module.exports = {
     link: require('./commands/link'),
     doc: require('./commands/doc'),
     feedback: require('./commands/feedback'),
+    performance: require('./commands/performance'),
+    perf: require('./commands/performance'),
+    extractCookie: require('./commands/extract-cookie'),
     skill: require('./commands/skill'),
     version: require('./commands/version'),
     update: require('./commands/update'),

package/src/lib/help.js

@@ -21,6 +21,8 @@ COMMANDS:
   link       Generate Magic share links
   doc        Create or append Feishu Doc HTML Box apps
   feedback   Create Magic feedback records
+  performance Submit Markdown content to a People performance draft (alias: perf)
+  extract-cookie Extract Cookie data from a curl command
   skill      Check or update the Magic Builder skill package
   version    Show CLI version
   update     Update this CLI package
@@ -45,6 +47,8 @@ EXAMPLES:
   magic-builder link create --title "Weekly Report"
   magic-builder doc create --html app.html --title "Demo"
   magic-builder feedback create --feedback "打不开页面"
+  magic-builder performance --cookie ./cookie.txt --markdown ./performance.md
+  magic-builder extract-cookie --curl-file ./request.curl
   magic-builder skill install
   magic-builder skill check-update
   magic-builder version
@@ -103,6 +107,11 @@ COMMANDS:
   feedback create --feedback <text> [--title <title>] [--summary <text>]
   feedback create --feedback-file <file> [--dry-run]
 
+  performance --cookie <content|file> --markdown <content|file|url> [--dry-run]
+  perf --cookie-file <file> --markdown-file <file> [--dry-run]
+
+  extract-cookie --curl <content|file> [--out <file>|--out-dir <dir>]
+
   skill install [--environment auto|local|cloud] [--skills-root <dir>]
   skill check-update [--environment auto|local|cloud] [--skills-root <dir>]
   skill update [--environment auto|local|cloud] [--skills-root <dir>]
@@ -184,6 +193,44 @@ SYNTAX:
 SYNTAX:
   magic-builder feedback create --feedback <text>
   magic-builder feedback create --feedback-file <file>
+`,
+  performance: `@HELP magic-builder/performance
+
+SYNTAX:
+  magic-builder performance --cookie <content|file> --markdown <content|file|url>
+  magic-builder perf --cookie-file <file> --markdown-file <file>
+
+COOKIE:
+  When --cookie and --cookie-file are omitted, ./cookie.txt is used.
+
+OPTIONS:
+  --dry-run                    Print the generated payload without sending it
+  --review-id <id>             Override the performance review id
+  --form-id <id>               Override the invitation/form id used by the draft key
+  --template-id <id>           Override the review template id
+  --root-review-id <id>        Override the root review id
+  --operator-id <id>           Override the current user/operator id
+  --source-id <id>             Override the form source id
+  --field-source-id <id>       Override the writable field source id
+  --tenant-id <id>             Override the People tenant id
+  --endpoint <url>             Override the draft API endpoint
+`,
+  perf: `@HELP magic-builder/performance
+
+Alias of "magic-builder performance".
+`,
+  'extract-cookie': `@HELP magic-builder/extract-cookie
+
+SYNTAX:
+  magic-builder extract-cookie --curl <content|file> [--out <file>]
+  magic-builder extract-cookie --curl-file <file> [--out-dir <dir>]
+  cat request.curl | magic-builder extract-cookie [--out <file>]
+
+OPTIONS:
+  --curl <content|file>   curl command text or a local curl file
+  --curl-file <file>      Read curl command from a local file
+  --out <file>            Output file (default: ./cookie.txt)
+  --out-dir <dir>         Output directory; created when missing
 `,
   skill: `@HELP magic-builder/skill
 

package/src/lib/multipart.js

@@ -26,13 +26,18 @@ async function uploadSingle(filePath, opts = {}) {
 
   if (signRes.code !== 0) throw new Error(signRes.msg || 'Sign failed');
   const { signed_url, url } = signRes.data;
+  const uploadHeaders = signRes.data.upload_headers || {};
 
   const buf = fs.readFileSync(filePath);
   if (!quiet) process.stderr.write('Uploading... ');
 
   await request(signed_url, {
     method: 'PUT',
-    headers: { 'Content-Type': mime },
+    headers: {
+      ...uploadHeaders,
+      'Content-Type': uploadHeaders['Content-Type'] || mime,
+      'Content-Disposition': uploadHeaders['Content-Disposition'] || 'inline',
+    },
     body: buf,
     timeout: 120000,
   });