apiskill 0.1.0

package/scripts/lib/mock-server.mjs

@@ -0,0 +1,262 @@
+import { createServer } from 'node:http';
+
+const METHODS = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+const DEFAULT_PORT = 4010;
+const DEFAULT_HOST = '127.0.0.1';
+
+export function hasMockableDocument(document) {
+  return Boolean(document?.paths && Object.keys(document.paths).length);
+}
+
+export function buildMockRoutes(document) {
+  const paths = document?.paths ?? {};
+  return Object.entries(paths)
+    .flatMap(([path, pathItem]) =>
+      METHODS.flatMap((method) => {
+        const operation = pathItem?.[method];
+        if (!operation) return [];
+        const response = selectResponse(operation);
+        return [
+          {
+            method: method.toUpperCase(),
+            path,
+            summary: operation.summary || operation.description || `${method.toUpperCase()} ${path}`,
+            status: response.status,
+            schema: response.schema,
+            regex: pathToRegex(path),
+          },
+        ];
+      }),
+    )
+    .sort((left, right) => routeRank(right.path) - routeRank(left.path));
+}
+
+export async function startMockServer({ document, meta, host = DEFAULT_HOST, port = DEFAULT_PORT } = {}) {
+  if (!hasMockableDocument(document)) {
+    throw new Error('当前没有可用的 API 文档数据，请先导入、爬取或新建文档后再启动 MOCK 服务');
+  }
+
+  const routes = buildMockRoutes(document);
+  if (!routes.length) {
+    throw new Error('当前 API 文档没有可 MOCK 的接口路径');
+  }
+
+  const server = createServer(async (req, res) => {
+    handleRequest(req, res, { document, meta, routes });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(Number(port) || DEFAULT_PORT, host || DEFAULT_HOST, () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+
+  const address = server.address();
+  const actualHost = typeof address === 'object' && address?.address ? address.address : host;
+  const actualPort = typeof address === 'object' && address?.port ? address.port : Number(port) || DEFAULT_PORT;
+
+  return {
+    server,
+    host: actualHost,
+    port: actualPort,
+    url: `http://${actualHost === '::' ? 'localhost' : actualHost}:${actualPort}`,
+    versionId: meta?.versionId || '',
+    title: meta?.title || document?.info?.title || '',
+    routesCount: routes.length,
+    routes: routes.map(({ method, path, summary, status }) => ({ method, path, summary, status })),
+  };
+}
+
+function handleRequest(req, res, context) {
+  setCorsHeaders(res);
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  const url = new URL(req.url || '/', 'http://localhost');
+  if (url.pathname === '/__apiskill_mock') {
+    sendJson(res, 200, {
+      ok: true,
+      versionId: context.meta?.versionId || '',
+      title: context.meta?.title || context.document?.info?.title || '',
+      routes: context.routes.map(({ method, path, summary, status }) => ({ method, path, summary, status })),
+    });
+    return;
+  }
+
+  const method = String(req.method || 'GET').toUpperCase();
+  const route = context.routes.find((item) => item.method === method && item.regex.test(url.pathname));
+  if (!route) {
+    sendJson(res, 404, {
+      error: 'Mock route not found',
+      method,
+      path: url.pathname,
+      available: context.routes.slice(0, 20).map((item) => `${item.method} ${item.path}`),
+    });
+    return;
+  }
+
+  const body = route.schema
+    ? mockValue(route.schema, context.document, { name: route.path })
+    : {
+        code: 0,
+        message: 'mock success',
+        data: {
+          method: route.method,
+          path: route.path,
+          requestPath: url.pathname,
+          timestamp: new Date().toISOString(),
+        },
+      };
+
+  sendJson(res, route.status, body);
+}
+
+function selectResponse(operation) {
+  const responses = operation.responses ?? {};
+  const entries = Object.entries(responses);
+  const preferred =
+    entries.find(([status]) => /^2\d\d$/.test(status)) ??
+    entries.find(([status]) => status === 'default') ??
+    entries[0];
+  const status = Number(preferred?.[0]) || 200;
+  const response = preferred?.[1] ?? {};
+  const contentEntry =
+    Object.entries(response.content ?? {}).find(([contentType]) => contentType.includes('json')) ??
+    Object.entries(response.content ?? {})[0];
+  return {
+    status,
+    schema: contentEntry?.[1]?.schema ?? response.schema ?? response.responseSchema,
+  };
+}
+
+function mockValue(schema, document, options = {}) {
+  const depth = options.depth ?? 0;
+  if (!schema || depth > 8) return null;
+  const resolved = resolveSchema(document, schema, options.seen ?? new Set()) ?? schema;
+  const name = String(options.name || '').toLowerCase();
+
+  if (Array.isArray(resolved.enum) && resolved.enum.length) return randomItem(resolved.enum);
+  if (Array.isArray(resolved.oneOf) && resolved.oneOf.length) return mockValue(randomItem(resolved.oneOf), document, { ...options, depth: depth + 1 });
+  if (Array.isArray(resolved.anyOf) && resolved.anyOf.length) return mockValue(randomItem(resolved.anyOf), document, { ...options, depth: depth + 1 });
+  if (Array.isArray(resolved.allOf) && resolved.allOf.length) {
+    return resolved.allOf.reduce((merged, item) => {
+      const next = mockValue(item, document, { ...options, depth: depth + 1 });
+      return isPlainObject(next) ? { ...(isPlainObject(merged) ? merged : {}), ...next } : next;
+    }, {});
+  }
+
+  const type = inferType(resolved);
+  if (type === 'array') {
+    return [0, 1].map(() => mockValue(resolved.items || { type: 'object' }, document, { ...options, depth: depth + 1 }));
+  }
+  if (type === 'object') {
+    const properties = resolved.properties ?? {};
+    if (!Object.keys(properties).length) {
+      if (resolved.additionalProperties && typeof resolved.additionalProperties === 'object') {
+        return { [sampleKey(name)]: mockValue(resolved.additionalProperties, document, { ...options, depth: depth + 1 }) };
+      }
+      return {};
+    }
+    return Object.fromEntries(
+      Object.entries(properties).map(([key, property]) => [
+        key,
+        mockValue(property, document, {
+          ...options,
+          name: key,
+          depth: depth + 1,
+        }),
+      ]),
+    );
+  }
+  if (type === 'integer') return randomInteger(name);
+  if (type === 'number') return Number((Math.random() * 1000).toFixed(2));
+  if (type === 'boolean') return Math.random() > 0.5;
+  return randomString(name, resolved.format);
+}
+
+function resolveSchema(document, schema, seen) {
+  if (!schema || typeof schema !== 'object') return undefined;
+  if (!schema.$ref) return schema;
+  if (seen.has(schema.$ref)) return {};
+  seen.add(schema.$ref);
+  const value = schema.$ref.startsWith('#/')
+    ? schema.$ref
+        .slice(2)
+        .split('/')
+        .reduce((current, key) => (current && typeof current === 'object' ? current[decodeURIComponent(key)] : undefined), document)
+    : undefined;
+  return resolveSchema(document, value, seen) ?? value;
+}
+
+function inferType(schema) {
+  if (schema.type) return Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (schema.properties || schema.additionalProperties) return 'object';
+  if (schema.items) return 'array';
+  return 'string';
+}
+
+function pathToRegex(path) {
+  const pattern = String(path || '/')
+    .replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+    .replace(/\\\{[^/]+\\\}/g, '[^/]+')
+    .replace(/:([A-Za-z0-9_]+)/g, '[^/]+');
+  return new RegExp(`^${pattern}/?$`);
+}
+
+function routeRank(path) {
+  return String(path).split('/').filter(Boolean).filter((part) => !part.startsWith('{') && !part.startsWith(':')).length;
+}
+
+function sendJson(res, status, body) {
+  const text = JSON.stringify(body, null, 2);
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(text),
+  });
+  res.end(text);
+}
+
+function setCorsHeaders(res) {
+  res.setHeader('access-control-allow-origin', '*');
+  res.setHeader('access-control-allow-methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS,HEAD');
+  res.setHeader('access-control-allow-headers', 'content-type,authorization,*');
+}
+
+function randomString(name, format) {
+  if (format === 'date-time') return new Date(Date.now() - randomInt(0, 1000000000)).toISOString();
+  if (format === 'date') return new Date(Date.now() - randomInt(0, 1000000000)).toISOString().slice(0, 10);
+  if (format === 'email' || name.includes('email')) return `user${randomInt(100, 999)}@example.com`;
+  if (format === 'uuid' || name.endsWith('id') || name.includes('uuid')) return `mock-${randomInt(100000, 999999)}`;
+  if (name.includes('phone') || name.includes('mobile')) return `138${randomInt(10000000, 99999999)}`;
+  if (name.includes('url')) return 'https://example.com/mock';
+  if (name.includes('name') || name.includes('title')) return `Mock ${randomInt(100, 999)}`;
+  if (name.includes('message') || name.includes('desc')) return 'Mock response generated by API Skill';
+  return `mock_${randomInt(1000, 9999)}`;
+}
+
+function randomInteger(name) {
+  if (name === 'code' || name.endsWith('code')) return 0;
+  if (name.endsWith('id') || name.includes('count') || name.includes('total')) return randomInt(1, 9999);
+  return randomInt(1, 100);
+}
+
+function sampleKey(name) {
+  return name ? `${name}Value` : 'mockKey';
+}
+
+function randomItem(items) {
+  return items[randomInt(0, items.length - 1)];
+}
+
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/scripts/lib/openapi-importer.mjs

@@ -0,0 +1,169 @@
+import { readFile } from 'node:fs/promises';
+import { parseOpenApiText, isOpenApiDocument } from './openapi-store.mjs';
+
+export async function importFromUrl(url, options = {}) {
+  const sourceUrl = normalizeUrl(url);
+  const response = await fetchText(sourceUrl, options);
+  const document = parseOpenApiText(response.text);
+  if (!isOpenApiDocument(document)) throw new Error('该地址未返回有效的 OpenAPI/Swagger JSON 或 YAML 文档');
+  return { document, resolvedUrl: response.url || sourceUrl };
+}
+
+export async function importFromLocalFile(filePath) {
+  const text = await readFile(filePath, 'utf8');
+  const document = parseOpenApiText(text);
+  if (!isOpenApiDocument(document)) throw new Error('本地文件不是有效的 OpenAPI/Swagger JSON 或 YAML 文档');
+  return { document, resolvedUrl: filePath };
+}
+
+export async function importFromCurl(curlText) {
+  const parsed = parseCurl(curlText);
+  const response = await fetchText(parsed.url, { method: parsed.method, headers: parsed.headers, body: parsed.body });
+  const document = parseOpenApiText(response.text);
+  if (!isOpenApiDocument(document)) throw new Error('CURL 响应不是有效的 OpenAPI/Swagger JSON 或 YAML 文档');
+  return { document, resolvedUrl: response.url || parsed.url };
+}
+
+export async function crawlOpenApi(pageUrl, options = {}) {
+  const sourceUrl = normalizeUrl(pageUrl);
+  const direct = await tryOpenApi(sourceUrl, options);
+  if (direct) return direct;
+
+  const page = await fetchText(sourceUrl, { ...options, accept: 'text/html,application/xhtml+xml,application/json,*/*' });
+  const candidates = discoverOpenApiUrls(page.url || sourceUrl, page.text);
+  for (const candidate of candidates) {
+    const result = await tryOpenApi(candidate, { ...options, referer: page.url || sourceUrl });
+    if (result) return result;
+  }
+  throw new Error('未在页面中识别到可用的 OpenAPI/Swagger JSON 或 YAML 地址');
+}
+
+async function tryOpenApi(url, options) {
+  try {
+    const response = await fetchText(url, options);
+    const document = parseOpenApiText(response.text);
+    if (isOpenApiDocument(document)) return { document, resolvedUrl: response.url || url };
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+async function fetchText(url, options = {}) {
+  const headers = {
+    accept: options.accept || 'application/json,application/yaml,text/yaml,text/plain,*/*',
+    'user-agent': options.userAgent || 'apiskill-cli/0.1.0',
+    ...(options.referer ? { referer: options.referer } : {}),
+    ...(options.headers ?? {}),
+  };
+  if (options.basicAuth) headers.authorization = `Basic ${Buffer.from(options.basicAuth, 'utf8').toString('base64')}`;
+  const response = await fetch(url, {
+    method: options.method || 'GET',
+    headers,
+    body: options.body,
+    redirect: 'follow',
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`请求失败 ${response.status}: ${url}`);
+  return { text, url: response.url };
+}
+
+function discoverOpenApiUrls(pageUrl, html) {
+  const urls = new Set();
+  const patterns = [
+    /spec-url\s*=\s*["'`]([^"'`]+)["'`]/gi,
+    /specUrl\s*[:=]\s*["'`]([^"'`]+)["'`]/g,
+    /url\s*:\s*["'`]([^"'`]+)["'`]/g,
+    /href=["']([^"']+(?:api-docs|swagger|openapi|api\.json|swagger\.json|\.ya?ml|\.json)[^"']*)["']/gi,
+    /src=["']([^"']+(?:api-docs|swagger|openapi|api\.json|swagger\.json|\.ya?ml|\.json)[^"']*)["']/gi,
+    /["'`]([^"'`]+(?:api-docs|swagger|openapi|api\.json|swagger\.json|\.ya?ml)[^"'`]*)["'`]/gi,
+  ];
+  for (const pattern of patterns) {
+    for (const match of html.matchAll(pattern)) addUrl(urls, pageUrl, match[1]);
+  }
+  [
+    '/api.json',
+    '/swagger.json',
+    '/openapi.json',
+    '/openapi.yaml',
+    '/swagger.yaml',
+    '/v2/api-docs',
+    '/v3/api-docs',
+    'api.json',
+    'swagger.json',
+    'openapi.json',
+    'openapi.yaml',
+    'swagger.yaml',
+  ].forEach((candidate) => addUrl(urls, pageUrl, candidate));
+  return [...urls];
+}
+
+function addUrl(urls, base, value) {
+  if (!value || value.startsWith('data:') || value.startsWith('javascript:')) return;
+  try {
+    urls.add(new URL(value.replace(/\\u002F/g, '/').replace(/&/g, '&'), base).toString());
+  } catch {
+    // Ignore malformed discovery candidates.
+  }
+}
+
+function parseCurl(curlText) {
+  const tokens = tokenize(curlText.replace(/\\\r?\n/g, ' '));
+  if (tokens[0] !== 'curl') throw new Error('CURL 命令必须以 curl 开头');
+  const headers = {};
+  let method = 'GET';
+  let body;
+  let url = '';
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    const next = () => tokens[++index];
+    if (token === '-H' || token === '--header') applyHeader(headers, next());
+    else if (token === '-X' || token === '--request') method = next().toUpperCase();
+    else if (token === '--url') url = next();
+    else if (['-d', '--data', '--data-raw', '--data-binary'].includes(token)) {
+      body = next();
+      if (method === 'GET') method = 'POST';
+    } else if (token === '-u' || token === '--user') headers.authorization = `Basic ${Buffer.from(next(), 'utf8').toString('base64')}`;
+    else if (!token.startsWith('-') && !url) url = token;
+  }
+  if (!url) throw new Error('CURL 命令中没有 URL');
+  return { url: normalizeUrl(url), method, headers, body };
+}
+
+function tokenize(value) {
+  const tokens = [];
+  let current = '';
+  let quote = '';
+  let escaping = false;
+  for (const char of value.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+    } else if (char === '\\' && quote !== "'") {
+      escaping = true;
+    } else if ((char === '"' || char === "'") && !quote) {
+      quote = char;
+    } else if (char === quote) {
+      quote = '';
+    } else if (!quote && /\s/.test(char)) {
+      if (current) tokens.push(current);
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+function applyHeader(headers, rawHeader = '') {
+  const index = rawHeader.indexOf(':');
+  if (index <= 0) return;
+  headers[rawHeader.slice(0, index).trim()] = rawHeader.slice(index + 1).trim();
+}
+
+function normalizeUrl(value) {
+  const url = new URL(String(value || '').trim());
+  if (!['http:', 'https:'].includes(url.protocol)) throw new Error('仅支持 http 或 https 地址');
+  return url.toString();
+}