magic-builder 0.1.0

package/bin/magic-builder.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+'use strict';
+
+const { renderHelp } = require('../src/lib/help');
+const { fail } = require('../src/lib/output');
+
+const COMMANDS = {
+  auth: require('../src/commands/auth'),
+  page: require('../src/commands/page'),
+  faas: require('../src/commands/faas'),
+  asset: require('../src/commands/asset'),
+  link: require('../src/commands/link'),
+  doc: require('../src/commands/doc'),
+  feedback: require('../src/commands/feedback'),
+  skill: require('../src/commands/skill'),
+  doctor: require('../src/commands/doctor'),
+  config: require('../src/commands/config'),
+};
+
+function parseGlobalArgs(argv) {
+  const opts = { format: 'json', quiet: false };
+  const args = [];
+  let command = null;
+  let i = 0;
+
+  while (i < argv.length) {
+    const a = argv[i];
+
+    if (!command && COMMANDS[a]) {
+      command = a;
+    } else if (!command && !a.startsWith('-')) {
+      fail(`Unknown command: ${a}. Run: magic-builder --help`, 'E_INVALID_ARGS');
+    } else if (a === '--help' || a === '-h') {
+      process.stdout.write(renderHelp('help', command) + '\n');
+      process.exit(0);
+    } else if (a === '--man') {
+      process.stdout.write(renderHelp('man') + '\n');
+      process.exit(0);
+    } else if (a === '--version' || a === '-v') {
+      process.stdout.write(require('../package.json').version + '\n');
+      process.exit(0);
+    } else if (a === '--base-url' || a === '--magic-base-url') {
+      opts.baseUrl = argv[++i];
+    } else if (a === '--token') {
+      opts.token = argv[++i];
+    } else if (a === '--format') {
+      opts.format = argv[++i];
+    } else if (a === '--quiet' || a === '-q') {
+      opts.quiet = true;
+    } else if (a.startsWith('--') && a.includes('=')) {
+      const eq = a.indexOf('=');
+      opts[toCamel(a.slice(2, eq))] = a.slice(eq + 1);
+    } else if (a.startsWith('--')) {
+      const name = a.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        opts[toCamel(name)] = next;
+        i++;
+      } else {
+        opts[toCamel(name)] = true;
+      }
+    } else if (!a.startsWith('-')) {
+      args.push(a);
+    } else {
+      fail(`Unknown option: ${a}. Run: magic-builder --help`, 'E_INVALID_ARGS');
+    }
+    i++;
+  }
+
+  return { command, args, opts };
+}
+
+function toCamel(value) {
+  return String(value || '').replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+
+  if (argv.length === 0) {
+    process.stdout.write(renderHelp('usage') + '\n');
+    process.exit(0);
+  }
+
+  const { command, args, opts } = parseGlobalArgs(argv);
+
+  if (!command) {
+    process.stdout.write(renderHelp('usage') + '\n');
+    process.exit(0);
+  }
+
+  try {
+    await COMMANDS[command].run(args, opts);
+  } catch (err) {
+    fail(err.message || 'Unexpected error', err.code || 'E_ERROR');
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "magic-builder",
+  "version": "0.1.0",
+  "description": "CLI for Magic Builder — publish pages, functions, and files",
+  "bin": {
+    "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"],
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/commands/asset.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const fs = require('fs');
+const { getBaseUrl } = require('../lib/config');
+const { shouldUseMultipart, uploadSingle, uploadMultipart } = require('../lib/multipart');
+const { success, fail, failFromHttpError } = require('../lib/output');
+
+async function run(args, opts) {
+  const sub = args[0];
+  if (sub !== 'upload') fail('Usage: magic-builder asset upload <file>', 'E_INVALID_ARGS');
+  const file = args[1];
+  if (!file) fail('Missing file argument. Usage: magic-builder asset upload <file>', 'E_INVALID_ARGS');
+  if (!fs.existsSync(file)) fail(`File not found: ${file}`, 'E_NOT_FOUND');
+
+  const stat = fs.statSync(file);
+  if (stat.size === 0) fail('File is empty', 'E_EMPTY_FILE');
+
+  const uploadOpts = {
+    baseUrl: getBaseUrl(opts),
+    key: opts.key,
+    contentType: opts.contentType,
+    quiet: opts.quiet,
+  };
+
+  let result;
+  try {
+    result = shouldUseMultipart(stat.size)
+      ? await uploadMultipart(file, uploadOpts)
+      : await uploadSingle(file, uploadOpts);
+  } catch (e) {
+    if (e.code) failFromHttpError(e);
+    fail(e.message, 'E_UPLOAD_FAILED');
+  }
+
+  success(result, opts);
+}
+
+module.exports = { run };

package/src/commands/auth.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const { getBaseUrl } = require('../lib/config');
+const { setToken, showToken, TOKEN_FILE } = require('../lib/auth');
+const { request } = require('../lib/http');
+const { success, fail } = require('../lib/output');
+
+async function run(args, opts) {
+  const sub = args[0];
+  if (sub === 'login') return login(opts);
+  if (sub === 'set') return set(args, opts);
+  if (sub === 'show') return show(opts);
+  fail('Usage: magic-builder auth <login|set|show>', 'E_INVALID_ARGS');
+}
+
+async function login(opts) {
+  const baseUrl = getBaseUrl(opts);
+  const timeoutSeconds = Number(opts.timeout || 600);
+  const intervalSeconds = Number(opts.interval || 2);
+  if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) fail('--timeout must be a positive number', 'E_INVALID_ARGS');
+  if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) fail('--interval must be a positive number', 'E_INVALID_ARGS');
+
+  const start = await request(`${baseUrl}/api/dev-token/auth/start`, {
+    method: 'POST',
+    body: {},
+  });
+  const data = start.data || {};
+  const requestId = String(data.request_id || '');
+  const pollToken = String(data.poll_token || '');
+  const authUrl = String(data.auth_url || '');
+  if (!requestId || !pollToken || !authUrl) {
+    fail(`Invalid auth start response: ${JSON.stringify(start)}`, 'E_AUTH_FAILED', 2);
+  }
+
+  if (!opts.quiet) {
+    process.stderr.write(`Open this URL to authorize:\n${authUrl}\n`);
+    if (!opts.noOpen) {
+      process.stderr.write(openBrowser(authUrl) ? 'Browser opened.\n' : 'Could not open browser automatically.\n');
+    }
+    process.stderr.write('Waiting for authorization...\n');
+  } else if (opts.format === 'plain') {
+    process.stdout.write(`${authUrl}\n`);
+  }
+
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  while (Date.now() < deadline) {
+    const tokenJson = await request(`${baseUrl}/api/dev-token/auth/token`, {
+      method: 'POST',
+      body: {
+        request_id: requestId,
+        poll_token: pollToken,
+      },
+      timeout: 15000,
+    });
+    const tokenData = tokenJson.data || {};
+    const status = String(tokenData.status || '');
+    if (status === 'completed') {
+      const token = String(tokenData.token || '');
+      if (!token) fail(`Completed auth response did not include token: ${JSON.stringify(tokenJson)}`, 'E_AUTH_FAILED', 2);
+      setToken(token);
+      success({
+        status: 'authenticated',
+        path: TOKEN_FILE,
+        user: String(tokenData.name || tokenData.open_id || '').trim(),
+        token: showToken(),
+      }, opts);
+      return;
+    }
+    if (status === 'pending') {
+      await sleep(intervalSeconds * 1000);
+      continue;
+    }
+    fail(`Unexpected auth status: ${JSON.stringify(tokenJson)}`, 'E_AUTH_FAILED', 2);
+  }
+  fail('Timed out waiting for authorization. Run auth login again.', 'E_AUTH_TIMEOUT', 2);
+}
+
+function set(args, opts) {
+  const value = args[1];
+  if (!value) fail('Missing token value. Usage: magic-builder auth set <value>', 'E_INVALID_ARGS');
+  setToken(value);
+  success({ status: 'saved', path: TOKEN_FILE }, opts);
+}
+
+function show(opts) {
+  const masked = showToken();
+  if (!masked) fail('No token configured. Run: magic-builder auth login', 'E_NO_TOKEN', 2);
+  success({ token: masked }, opts);
+}
+
+function openBrowser(url) {
+  const command = process.platform === 'darwin'
+    ? 'open'
+    : process.platform === 'win32'
+      ? 'cmd'
+      : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = { run };

package/src/commands/config.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { getBaseUrl } = require('../lib/config');
+const { TOKEN_FILE, showToken } = require('../lib/auth');
+const { success, fail } = require('../lib/output');
+
+async function run(args, opts) {
+  const sub = args[0];
+  if (sub !== 'get') fail('Usage: magic-builder config get', 'E_INVALID_ARGS');
+  success({
+    base_url: getBaseUrl(opts),
+    token_file: TOKEN_FILE,
+    token: showToken() || '',
+  }, opts);
+}
+
+module.exports = { run };

package/src/commands/doc.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { readFileSync } = require('fs');
+const { execFileSync } = require('child_process');
+const { success, fail } = require('../lib/output');
+
+const HTML_BOX_COMPONENT_TYPE_ID = 'blk_6900429af84180025ce76527';
+
+async function run(args, opts) {
+  const sub = args[0];
+  if (sub !== 'create' && sub !== 'append') fail('Usage: magic-builder doc <create|append> --html <file>', 'E_INVALID_ARGS');
+  if (!opts.html) fail('Missing --html', 'E_INVALID_ARGS');
+  if (sub === 'create' && !opts.title) fail('Missing --title', 'E_INVALID_ARGS');
+  if (sub === 'append' && !opts.docToken) fail('Missing --doc-token', 'E_INVALID_ARGS');
+
+  const html = readFileSync(opts.html, 'utf8');
+  const record = buildRecord(opts, html);
+  const identity = resolveIdentity(opts.as);
+  const created = sub === 'append'
+    ? { docToken: opts.docToken, url: `https://bytedance.larkoffice.com/docx/${opts.docToken}` }
+    : createDocument(opts.title, opts.summary, identity);
+  const htmlBoxBlockId = insertHtmlBox(created.docToken, record, identity);
+
+  success({
+    ok: true,
+    identity,
+    doc_token: created.docToken,
+    doc_url: created.url,
+    html_box_block_id: htmlBoxBlockId,
+  }, opts);
+}
+
+function buildRecord(opts, html) {
+  const record = { html };
+  const json = readOptionalText(opts.recordJson);
+  const js = readOptionalText(opts.recordJs);
+  const scripts = splitCsv(opts.recordScripts);
+  if (json !== undefined) record.json = json;
+  if (js !== undefined) record.js = js;
+  if (scripts.length > 0) record.scripts = scripts;
+  return record;
+}
+
+function resolveIdentity(requestedIdentity) {
+  if (requestedIdentity) {
+    if (requestedIdentity !== 'bot' && requestedIdentity !== 'user') fail('--as must be bot or user', 'E_INVALID_ARGS');
+    return requestedIdentity;
+  }
+  const status = runJson(['auth', 'status']);
+  if (status?.identity === 'user' || status?.identity === 'bot') return status.identity;
+  return 'bot';
+}
+
+function createDocument(title, summary, identity) {
+  const intro = summary || `这个妙笔应用以交互式网页的形式展示「${title}」，可直接在文档中查看和体验。`;
+  const content = `<title>${escapeXml(title)}</title><p>${escapeXml(intro)}</p>`;
+  const resp = runJson([
+    'docs',
+    '+create',
+    '--as',
+    identity,
+    '--api-version',
+    'v2',
+    '--content',
+    content,
+  ]);
+  if (!resp?.ok || !resp?.data?.document?.document_id) {
+    throw new Error(`failed to create document: ${JSON.stringify(resp)}`);
+  }
+  return {
+    docToken: resp.data.document.document_id,
+    url: resp.data.document.url,
+  };
+}
+
+function insertHtmlBox(docToken, recordObject, identity) {
+  const record = JSON.stringify(recordObject);
+  const resp = runJson([
+    'api',
+    'POST',
+    `/open-apis/docx/v1/documents/${docToken}/blocks/${docToken}/children`,
+    '--as',
+    identity,
+    '--data',
+    JSON.stringify({
+      children: [{
+        block_type: 40,
+        add_ons: {
+          component_id: '',
+          component_type_id: HTML_BOX_COMPONENT_TYPE_ID,
+          record,
+        },
+      }],
+      index: -1,
+    }),
+  ]);
+  if (resp?.code !== 0) throw new Error(`failed to insert HTML Box: ${JSON.stringify(resp)}`);
+  const block = resp?.data?.children?.[0];
+  const returnedRecord = parseRecordValue(block?.add_ons?.record);
+  if (!recordIncludes(recordObject, returnedRecord)) {
+    throw new Error(`inserted HTML Box record mismatch: ${JSON.stringify(block?.add_ons)}`);
+  }
+  return block?.block_id || '';
+}
+
+function runJson(commandArgs) {
+  const out = execFileSync('lark-cli', commandArgs, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return JSON.parse(out);
+}
+
+function readOptionalText(file) {
+  return file ? readFileSync(file, 'utf8') : undefined;
+}
+
+function splitCsv(value) {
+  return String(value || '').split(',').map((item) => item.trim()).filter(Boolean);
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function parseRecordValue(value) {
+  if (typeof value === 'string') {
+    try { return JSON.parse(value); } catch { return null; }
+  }
+  if (value && typeof value === 'object') return value;
+  return null;
+}
+
+function recordIncludes(expected, actual) {
+  if (!actual || typeof actual !== 'object') return false;
+  return Object.keys(expected).every((key) => stableStringify(actual[key]) === stableStringify(expected[key]));
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+module.exports = { run };

package/src/commands/doctor.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+const { getBaseUrl } = require('../lib/config');
+const { showToken, TOKEN_FILE } = require('../lib/auth');
+const { success } = require('../lib/output');
+
+async function run(args, opts) {
+  const checks = [];
+  checks.push({ name: 'node', ok: true, detail: process.version });
+  checks.push({ name: 'base_url', ok: true, detail: getBaseUrl(opts) });
+  checks.push({ name: 'token', ok: !!showToken(), detail: showToken() ? `configured at ${process.env.MAGIC_TOKEN ? 'MAGIC_TOKEN' : TOKEN_FILE}` : 'not configured' });
+  checks.push({ name: 'token_file_writable', ok: canWriteTokenFile(), detail: TOKEN_FILE });
+  checks.push({ name: 'lark-cli', ...commandCheck('lark-cli') });
+  checks.push({ name: 'unzip', ...commandCheck('unzip') });
+  success({ ok: checks.every((item) => item.ok), checks }, opts);
+}
+
+function commandCheck(command) {
+  const result = spawnSync(command, ['--version'], { encoding: 'utf8' });
+  return {
+    ok: result.status === 0,
+    detail: result.status === 0 ? (result.stdout || result.stderr || '').trim().split(/\r?\n/)[0] : 'not found or failed',
+  };
+}
+
+function canWriteTokenFile() {
+  try {
+    if (fs.existsSync(TOKEN_FILE)) {
+      fs.accessSync(TOKEN_FILE, fs.constants.W_OK);
+      return true;
+    }
+    fs.accessSync(require('path').dirname(TOKEN_FILE), fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { run };

package/src/commands/faas.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getToken } = require('../lib/auth');
+const { getBaseUrl } = require('../lib/config');
+const { request } = require('../lib/http');
+const { success, fail, failFromHttpError } = require('../lib/output');
+
+async function run(args, opts) {
+  const sub = args[0];
+  if (sub !== 'publish') fail('Usage: magic-builder faas publish <file.js>', 'E_INVALID_ARGS');
+  args = args.slice(1);
+  let code;
+
+  if (opts.code) {
+    code = opts.code;
+  } else {
+    const file = args[0];
+    if (!file) fail('Missing file argument. Usage: magic-builder faas publish <file.js> or --code <string>', 'E_INVALID_ARGS');
+    if (!fs.existsSync(file)) fail(`File not found: ${file}`, 'E_NOT_FOUND');
+    code = fs.readFileSync(file, 'utf8');
+    if (!code.trim()) fail('JS file is empty', 'E_EMPTY_FILE');
+  }
+
+  let token;
+  try { token = await getToken(opts); } catch (e) { fail(e.message, 'E_NO_TOKEN', 2); }
+
+  const baseUrl = getBaseUrl(opts);
+  const name = opts.name || generateName(args[0]);
+
+  const body = { code, name };
+  if (opts.id) body.id = opts.id;
+
+  if (!opts.quiet) process.stderr.write(`Deploying FaaS${opts.name ? ` "${opts.name}"` : ''}... `);
+
+  let res;
+  try {
+    res = await request(`${baseUrl}/api/faas`, {
+      method: 'POST',
+      token,
+      body,
+    });
+  } catch (e) { failFromHttpError(e); }
+
+  if (res.code !== 0) fail(res.msg || 'FaaS publish failed', 'E_PUBLISH_FAILED');
+
+  const data = res.data || res;
+  const id = data.id || data.record_id;
+  const faasUrl = data.faas_url || `/api/faas/${id}`;
+
+  if (!opts.quiet) process.stderr.write('done\n');
+
+  const wsBaseUrl = baseUrl.replace(/^https?/, 'wss');
+
+  success({
+    id: data.record_id || id,
+    faas_url: `${baseUrl}${faasUrl}`,
+    preview_url: `${baseUrl}/r?fid=${id}`,
+    wss_url: `${wsBaseUrl}${faasUrl}`,
+  }, opts);
+}
+
+function generateName(filePath) {
+  if (!filePath) return `func_${Date.now().toString(36)}`;
+  const base = path.basename(filePath, path.extname(filePath));
+  return base.replace(/[^a-zA-Z0-9_]/g, '_').slice(0, 50);
+}
+
+module.exports = { run };