apiskill 0.1.4 → 0.1.6

package/scripts/test-shared-cache.mjs

@@ -0,0 +1,175 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:net';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { getDefaultCacheDir } from './lib/cache-paths.mjs';
+
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const cliPath = resolve(projectRoot, 'scripts/apiskill-cli.mjs');
+const testRoot = await mkdtemp(join(tmpdir(), 'apiskill-shared-cache-'));
+const cacheDir = resolve(testRoot, 'active-cache');
+const defaultCacheDir = resolve(testRoot, 'default-cache');
+const configDir = resolve(testRoot, 'config');
+const port = await findFreePort();
+let webProcess;
+
+try {
+  await mkdir(cacheDir, { recursive: true });
+  assert.equal(getDefaultCacheDir({ APISKILL_ROOT: '/tmp/another-project' }), resolve(homedir(), '.apiskill', 'cache'));
+
+  const created = JSON.parse(
+    await runCli(['document', 'create', '--title', 'Shared Cache Test', '--doc-version', '1.0.0', '--json']),
+  );
+  const versionId = created.meta.versionId;
+  await runCli([
+    'api',
+    'create',
+    '--version',
+    versionId,
+    '--config',
+    JSON.stringify({
+      api: {
+        method: 'get',
+        path: '/api/v1/from-cli',
+        summary: 'Created from CLI',
+        responses: [{ status: '200', description: 'Success' }],
+      },
+    }),
+    '--json',
+  ]);
+
+  webProcess = spawn(
+    process.execPath,
+    [cliPath, 'run', 'web', '--host', '127.0.0.1', '--port', String(port), '--strict-port', '--cwd', projectRoot],
+    {
+      cwd: projectRoot,
+      env: { ...process.env, APISKILL_CACHE_DIR: cacheDir, APISKILL_CONFIG_DIR: configDir },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  const webOutput = collectProcessOutput(webProcess);
+  await waitForWeb(port, webProcess, webOutput);
+
+  const webCacheResponse = await fetch(`http://127.0.0.1:${port}/api/openapi/cache`);
+  assert.equal(webCacheResponse.status, 200);
+  const webCache = await webCacheResponse.json();
+  assert.equal(webCache.meta.versionId, versionId);
+  assert.ok(webCache.document.paths['/api/v1/from-cli']?.get, 'Web did not read the API created by CLI');
+
+  const webWriteResponse = await fetch(`http://127.0.0.1:${port}/api/openapi/custom-operation`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      versionId,
+      config: {
+        method: 'post',
+        path: '/api/v1/from-web',
+        summary: 'Created from Web',
+        responses: [{ status: '201', description: 'Created' }],
+      },
+    }),
+  });
+  assert.equal(webWriteResponse.status, 200, await webWriteResponse.text());
+
+  const cliRead = JSON.parse(await runCli(['api', 'query', 'POST', '/api/v1/from-web', '--version', versionId]));
+  assert.equal(cliRead.path, '/api/v1/from-web');
+  assert.equal(cliRead.method, 'post');
+
+  const check = JSON.parse(await runCli(['check', '--json']));
+  assert.equal(check.cacheDir, cacheDir);
+
+  const settingsResponse = await fetch(`http://127.0.0.1:${port}/api/cache-settings`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ cacheDir: defaultCacheDir }),
+  });
+  const settings = await settingsResponse.json();
+  assert.equal(settingsResponse.status, 200, JSON.stringify(settings));
+  assert.equal(settings.activeCacheDir, cacheDir);
+  assert.equal(settings.defaultCacheDir, defaultCacheDir);
+  assert.equal(settings.environmentOverride, true);
+
+  const syncResponse = await fetch(`http://127.0.0.1:${port}/api/openapi/version-sync-cache`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ versionId }),
+  });
+  const synced = await syncResponse.json();
+  assert.equal(syncResponse.status, 200, JSON.stringify(synced));
+  assert.equal(synced.targetCacheDir, defaultCacheDir);
+  assert.ok(existsSync(resolve(cacheDir, 'versions', `${versionId}.json`)), 'Sync removed the source document');
+  assert.ok(existsSync(resolve(defaultCacheDir, 'versions', `${versionId}.json`)), 'Sync did not create the target document');
+
+  const cliFromNewDefault = JSON.parse(
+    await runCli(['api', 'query', 'POST', '/api/v1/from-web'], { cacheOverride: false }),
+  );
+  assert.equal(cliFromNewDefault.path, '/api/v1/from-web');
+  console.log(`Shared cache test passed: Web and CLI synchronized ${versionId} from ${cacheDir} to ${defaultCacheDir}.`);
+} finally {
+  if (webProcess && webProcess.exitCode === null) {
+    webProcess.kill('SIGTERM');
+    await new Promise((resolvePromise) => webProcess.once('close', resolvePromise));
+  }
+  await rm(testRoot, { recursive: true, force: true });
+}
+
+function runCli(args, { cacheOverride = true } = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const env = { ...process.env, APISKILL_CONFIG_DIR: configDir };
+    if (cacheOverride) env.APISKILL_CACHE_DIR = cacheDir;
+    else delete env.APISKILL_CACHE_DIR;
+    const child = spawn(process.execPath, [cliPath, ...args], {
+      cwd: projectRoot,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const output = collectProcessOutput(child);
+    child.on('error', rejectPromise);
+    child.on('close', (code) => {
+      if (code === 0) resolvePromise(output.stdout);
+      else rejectPromise(new Error(`apiskill ${args.join(' ')} failed (${code}): ${output.stderr || output.stdout}`));
+    });
+  });
+}
+
+function collectProcessOutput(child) {
+  const output = { stdout: '', stderr: '' };
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => {
+    output.stdout += chunk;
+  });
+  child.stderr.on('data', (chunk) => {
+    output.stderr += chunk;
+  });
+  return output;
+}
+
+async function waitForWeb(webPort, child, output) {
+  const deadline = Date.now() + 15_000;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) throw new Error(`Web process exited early (${child.exitCode}): ${output.stderr || output.stdout}`);
+    try {
+      const response = await fetch(`http://127.0.0.1:${webPort}/api/openapi/versions`);
+      if (response.ok) return;
+    } catch {}
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 100));
+  }
+  throw new Error(`Timed out waiting for Web: ${output.stderr || output.stdout}`);
+}
+
+function findFreePort() {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const server = createServer();
+    server.once('error', rejectPromise);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const freePort = typeof address === 'object' && address ? address.port : 0;
+      server.close((error) => (error ? rejectPromise(error) : resolvePromise(freePort)));
+    });
+  });
+}

package/src/App.tsx

@@ -44,9 +44,12 @@ import {
   VERSION_DELETE_API_URL,
   VERSION_META_API_URL,
   VERSION_SELECT_API_URL,
+  VERSION_SYNC_CACHE_API_URL,
   VERSIONS_API_URL,
 } from './swagger';
 import { AddApiDialog } from './AddApiDialog';
+import { CacheSettingsDialog, loadCacheSettings } from './CacheSettingsDialog';
+import type { CacheSettings } from './CacheSettingsDialog';
 import { DocumentVersionManager } from './DocumentVersionManager';
 import type { DocumentVersionMeta } from './DocumentVersionManager';
 import type { ManualApiOperationConfig } from './manualApiConfig';
@@ -125,6 +128,16 @@ type VersionDeleteResponse = {
   nextVersionId?: string;
 };
 
+type VersionCacheSyncResponse = {
+  status: 'synced' | 'already-current';
+  versionId: string;
+  sourceCacheDir: string;
+  sourceDocumentPath: string;
+  targetCacheDir: string;
+  targetDocumentPath: string;
+  syncedAt?: string;
+};
+
 type AuthCheckResponse = {
   requiresAuth: boolean;
   status?: number;
@@ -220,6 +233,7 @@ export function App() {
   const [editingApiTarget, setEditingApiTarget] = useState<{ method: HttpMethod; path: string } | undefined>(undefined);
   const [operationLinkDrafts, setOperationLinkDrafts] = useState<Record<string, EndpointAssociationLinks>>({});
   const [savingApi, setSavingApi] = useState(false);
+  const [cacheSettings, setCacheSettings] = useState<CacheSettings | undefined>(undefined);
   const uploadInputRef = useRef<HTMLInputElement | null>(null);
 
   useEffect(() => {
@@ -236,6 +250,7 @@ export function App() {
 
     loadInitialCache();
     void loadMockStatus();
+    void loadCacheSettings().then(setCacheSettings).catch(() => {});
   }, []);
 
   const endpoints = useMemo(() => (doc ? listEndpoints(doc) : []), [doc]);
@@ -756,6 +771,17 @@ export function App() {
     setLoadState('ready');
   }
 
+  async function syncVersionToDefaultCache(versionId: string) {
+    const response = await fetch(VERSION_SYNC_CACHE_API_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ versionId }),
+    });
+    const payload = await response.json();
+    if (!response.ok) throw new Error(payload.error || '文档同步到默认缓存地址失败');
+    return payload as VersionCacheSyncResponse;
+  }
+
   async function loadMockStatus() {
     try {
       const response = await fetch(MOCK_STATUS_API_URL, { cache: 'no-store' });
@@ -940,6 +966,8 @@ export function App() {
             onPrepareUpdate={prepareVersionUpdate}
             onUpdateEnvironment={updateVersionEnvironment}
             onDelete={deleteVersion}
+            cacheSettings={cacheSettings}
+            onSyncCache={syncVersionToDefaultCache}
           />
           <button
             className="primary-button"
@@ -957,6 +985,7 @@ export function App() {
             <span>Schema {stats.schemas}</span>
             <span>{lastSync ? `同步 ${formatDate(lastSync)}` : '未加载文档'}</span>
           </div>
+          <CacheSettingsDialog settings={cacheSettings} onSettingsChange={setCacheSettings} />
         </div>
       </header>
 

package/src/CacheSettingsDialog.tsx

@@ -0,0 +1,166 @@
+import { useState } from 'react';
+import { AlertCircle, FolderCog, RotateCcw, Save, X } from 'lucide-react';
+import { CACHE_SETTINGS_API_URL } from './swagger';
+
+export type CacheSettings = {
+  activeCacheDir: string;
+  defaultCacheDir: string;
+  configuredCacheDir: string;
+  builtInCacheDir: string;
+  environmentCacheDir: string;
+  environmentOverride: boolean;
+  effectiveNextCacheDir: string;
+  source: 'environment' | 'config' | 'default';
+  configPath: string;
+  restartRequired: boolean;
+  activeMatchesDefault: boolean;
+};
+
+export function CacheSettingsDialog({
+  settings,
+  onSettingsChange,
+}: {
+  settings?: CacheSettings;
+  onSettingsChange: (settings: CacheSettings) => void;
+}) {
+  const [open, setOpen] = useState(false);
+  const [cacheDir, setCacheDir] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [message, setMessage] = useState('');
+  const [error, setError] = useState('');
+
+  async function openDialog() {
+    setOpen(true);
+    setMessage('');
+    setError('');
+    setLoading(true);
+    try {
+      const next = await loadCacheSettings();
+      onSettingsChange(next);
+      setCacheDir(next.defaultCacheDir);
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError.message : '缓存设置读取失败');
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function saveSettings(reset = false) {
+    setLoading(true);
+    setMessage('');
+    setError('');
+    try {
+      const response = await fetch(CACHE_SETTINGS_API_URL, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(reset ? { reset: true } : { cacheDir }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.error || '缓存设置保存失败');
+      const next = payload as CacheSettings;
+      onSettingsChange(next);
+      setCacheDir(next.defaultCacheDir);
+      setMessage(reset ? '已恢复内置默认地址，现有缓存文件未改动' : '默认缓存地址已保存，现有缓存文件未改动');
+    } catch (saveError) {
+      setError(saveError instanceof Error ? saveError.message : '缓存设置保存失败');
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <>
+      <button className="secondary-button cache-settings-trigger" onClick={openDialog} title="设置接口文档默认缓存地址">
+        <FolderCog size={16} />
+        缓存设置
+      </button>
+
+      {open ? (
+        <div className="modal-backdrop" role="dialog" aria-modal="true" aria-labelledby="cache-settings-title">
+          <div className="cache-settings-dialog">
+            <div className="import-dialog-header">
+              <div>
+                <p className="eyebrow">Cache Settings</p>
+                <h2 id="cache-settings-title">接口文档缓存设置</h2>
+              </div>
+              <button className="icon-secondary-button" onClick={() => setOpen(false)} aria-label="关闭">
+                <X size={17} />
+              </button>
+            </div>
+
+            <div className="cache-settings-body">
+              {error ? <div className="version-message error">{error}</div> : null}
+              {message ? <div className="version-message">{message}</div> : null}
+
+              <div className="cache-location-row">
+                <span>当前会话缓存位置</span>
+                <code>{settings?.activeCacheDir || (loading ? '读取中...' : '-')}</code>
+              </div>
+
+              <label className="cache-settings-field">
+                默认缓存地址
+                <input
+                  value={cacheDir}
+                  onChange={(event) => setCacheDir(event.target.value)}
+                  placeholder="例如 ~/.apiskill/cache"
+                  autoComplete="off"
+                  disabled={loading}
+                />
+              </label>
+
+              <div className="cache-settings-notice">
+                <AlertCircle size={18} />
+                <div>
+                  <strong>修改地址不会移动或删除已有缓存文件</strong>
+                  <p>新的 CLI、MCP 进程会读取该默认地址；Web 端重启后切换。需要保留的版本可在版本管理中使用“更新缓存地址”复制过去。</p>
+                </div>
+              </div>
+
+              {settings?.environmentOverride ? (
+                <div className="cache-settings-notice warning">
+                  <AlertCircle size={18} />
+                  <div>
+                    <strong>环境变量正在覆盖默认设置</strong>
+                    <p>当前 `APISKILL_CACHE_DIR` 为 {settings.environmentCacheDir}。只要该变量存在，重启后仍优先使用它。</p>
+                  </div>
+                </div>
+              ) : null}
+
+              <dl className="cache-settings-details">
+                <div>
+                  <dt>内置默认地址</dt>
+                  <dd>{settings?.builtInCacheDir || '-'}</dd>
+                </div>
+                <div>
+                  <dt>配置文件</dt>
+                  <dd>{settings?.configPath || '-'}</dd>
+                </div>
+              </dl>
+            </div>
+
+            <div className="import-dialog-actions cache-settings-actions">
+              <button className="secondary-button" onClick={() => void saveSettings(true)} disabled={loading}>
+                <RotateCcw size={16} />
+                恢复默认
+              </button>
+              <div>
+                <button className="secondary-button" onClick={() => setOpen(false)} disabled={loading}>取消</button>
+                <button className="primary-button" onClick={() => void saveSettings(false)} disabled={loading || !cacheDir.trim()}>
+                  <Save size={16} />
+                  {loading ? '保存中' : '保存设置'}
+                </button>
+              </div>
+            </div>
+          </div>
+        </div>
+      ) : null}
+    </>
+  );
+}
+
+export async function loadCacheSettings(): Promise<CacheSettings> {
+  const response = await fetch(CACHE_SETTINGS_API_URL, { cache: 'no-store' });
+  const payload = await response.json();
+  if (!response.ok) throw new Error(payload.error || '缓存设置读取失败');
+  return payload as CacheSettings;
+}

package/src/DocumentVersionManager.tsx

@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useState } from 'react';
-import { Check, Download, Pencil, RefreshCcw, Server, Trash2, X } from 'lucide-react';
+import { Check, Download, FolderSync, Pencil, RefreshCcw, Server, Trash2, X } from 'lucide-react';
+import type { CacheSettings } from './CacheSettingsDialog';
 import { VERSION_EXPORT_API_URL } from './swagger';
 
 export type DocumentVersionMeta = {
@@ -14,6 +15,7 @@ export type DocumentVersionMeta = {
   schemas?: number;
   environmentName?: string;
   environmentBaseUrl?: string;
+  savedPath?: string;
 };
 
 export function DocumentVersionManager({
@@ -25,6 +27,8 @@ export function DocumentVersionManager({
   onPrepareUpdate,
   onUpdateEnvironment,
   onDelete,
+  cacheSettings,
+  onSyncCache,
 }: {
   versions: DocumentVersionMeta[];
   selectedVersionId: string;
@@ -34,6 +38,12 @@ export function DocumentVersionManager({
   onPrepareUpdate: (version: DocumentVersionMeta) => Promise<void> | void;
   onUpdateEnvironment: (versionId: string, environmentName: string, environmentBaseUrl: string) => Promise<void>;
   onDelete: (versionId: string) => Promise<void>;
+  cacheSettings?: CacheSettings;
+  onSyncCache: (versionId: string) => Promise<{
+    status: 'synced' | 'already-current';
+    targetCacheDir: string;
+    targetDocumentPath: string;
+  }>;
 }) {
   const [open, setOpen] = useState(false);
   const [editingVersionId, setEditingVersionId] = useState('');
@@ -118,6 +128,38 @@ export function DocumentVersionManager({
     document.body.removeChild(anchor);
   }
 
+  async function syncVersionCache(version: DocumentVersionMeta) {
+    const versionId = version.versionId;
+    if (!versionId) return;
+    if (!cacheSettings) {
+      setMessage('缓存设置尚未读取，请稍后重试');
+      return;
+    }
+
+    const sourceLocation = version.savedPath || cacheSettings.activeCacheDir;
+    const targetLocation = cacheSettings.defaultCacheDir;
+    if (cacheSettings.activeMatchesDefault) {
+      window.alert(`当前缓存位置：\n${sourceLocation}\n\n该版本已位于默认缓存地址：\n${targetLocation}`);
+      return;
+    }
+
+    const confirmed = window.confirm(
+      `当前缓存位置：\n${sourceLocation}\n\n默认缓存地址：\n${targetLocation}\n\n确认将该文档版本复制到默认缓存地址吗？源文件不会被移动或删除；目标中同版本内容将被更新。`,
+    );
+    if (!confirmed) return;
+
+    setBusyVersionId(versionId);
+    setMessage('');
+    try {
+      const result = await onSyncCache(versionId);
+      setMessage(result.status === 'already-current' ? '该版本已位于默认缓存地址' : `已同步到 ${result.targetDocumentPath}`);
+    } catch (error) {
+      setMessage(error instanceof Error ? error.message : '更新缓存地址失败');
+    } finally {
+      setBusyVersionId('');
+    }
+  }
+
   return (
     <div className="version-manager">
       <button className="version-manager-trigger" onClick={() => setOpen(true)} disabled={disabled || !versions.length}>
@@ -231,6 +273,10 @@ export function DocumentVersionManager({
                           <Download size={15} />
                           导出
                         </button>
+                        <button className="secondary-button" onClick={() => void syncVersionCache(version)} disabled={busy || !versionId}>
+                          <FolderSync size={15} />
+                          更新缓存地址
+                        </button>
                         <button className="danger-button" onClick={() => deleteVersion(version)} disabled={busy || !versionId}>
                           <Trash2 size={15} />
                           删除

package/src/styles.css

@@ -75,7 +75,10 @@ p {
 .topbar-actions {
   display: flex;
   align-items: center;
+  justify-content: flex-end;
+  flex-wrap: wrap;
   gap: 14px;
+  min-width: 0;
 }
 
 .version-switcher {
@@ -1542,6 +1545,110 @@ td code {
   box-shadow: 0 18px 60px rgba(18, 25, 35, 0.22);
 }
 
+.cache-settings-dialog {
+  width: min(680px, 100%);
+  max-height: calc(100vh - 40px);
+  overflow: auto;
+  border: 1px solid #d7dde4;
+  border-radius: 8px;
+  background: #fff;
+  box-shadow: 0 18px 60px rgba(18, 25, 35, 0.22);
+}
+
+.cache-settings-body {
+  display: grid;
+  gap: 16px;
+  padding: 18px 20px;
+}
+
+.cache-location-row,
+.cache-settings-details > div {
+  display: grid;
+  grid-template-columns: 150px minmax(0, 1fr);
+  align-items: start;
+  gap: 14px;
+}
+
+.cache-location-row > span,
+.cache-settings-details dt {
+  color: #657181;
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.cache-location-row code,
+.cache-settings-details dd {
+  min-width: 0;
+  margin: 0;
+  overflow-wrap: anywhere;
+  color: #1d2a36;
+  font-size: 12px;
+}
+
+.cache-settings-field {
+  display: grid;
+  gap: 7px;
+  color: #334152;
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.cache-settings-field input {
+  width: 100%;
+  min-height: 40px;
+  padding: 0 11px;
+  border: 1px solid #bdc8d4;
+  border-radius: 6px;
+  outline: 0;
+  color: #15202c;
+  background: #fff;
+}
+
+.cache-settings-field input:focus {
+  border-color: #1b6b65;
+  box-shadow: 0 0 0 3px rgba(27, 107, 101, 0.12);
+}
+
+.cache-settings-notice {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 10px;
+  padding: 12px 0;
+  border-block: 1px solid #dbe7e4;
+  color: #285c55;
+}
+
+.cache-settings-notice.warning {
+  border-color: #ead9ad;
+  color: #765b16;
+}
+
+.cache-settings-notice strong {
+  font-size: 13px;
+}
+
+.cache-settings-notice p {
+  margin: 4px 0 0;
+  color: #657181;
+  font-size: 12px;
+  line-height: 1.55;
+}
+
+.cache-settings-details {
+  display: grid;
+  gap: 9px;
+  margin: 0;
+}
+
+.cache-settings-actions {
+  justify-content: space-between;
+}
+
+.cache-settings-actions > div {
+  display: flex;
+  gap: 8px;
+}
+
 .api-config-dialog {
   width: 80vw;
   min-width: 1000px;
@@ -2260,6 +2367,18 @@ td code {
     gap: 8px;
   }
 
+  .cache-location-row,
+  .cache-settings-details > div {
+    grid-template-columns: 1fr;
+    gap: 5px;
+  }
+
+  .cache-settings-actions,
+  .cache-settings-actions > div {
+    display: grid;
+    width: 100%;
+  }
+
   .endpoint-title-line {
     align-items: flex-start;
     flex-direction: column;

package/src/swagger.ts

@@ -19,6 +19,8 @@ export const VERSION_SELECT_API_URL = '/api/openapi/version-select';
 export const VERSION_META_API_URL = '/api/openapi/version-meta';
 export const VERSION_DELETE_API_URL = '/api/openapi/version-delete';
 export const VERSION_EXPORT_API_URL = '/api/openapi/version-export';
+export const VERSION_SYNC_CACHE_API_URL = '/api/openapi/version-sync-cache';
+export const CACHE_SETTINGS_API_URL = '/api/cache-settings';
 export const MOCK_START_API_URL = '/api/mock/start';
 export const MOCK_STATUS_API_URL = '/api/mock/status';
 export const MOCK_STOP_API_URL = '/api/mock/stop';