rol-websocket-channel 1.4.2 → 1.4.9

package/index.ts

@@ -653,6 +653,7 @@ function registerAdminBridgeCli(api: any) {
     ({ program }: { program: any }) => {
       const root = program
         .command("admin-bridge")
+        .alias("rol-websocket-channel")
         .description("OpenClaw admin bridge utilities")
         .addHelpText(
           "after",
@@ -810,6 +811,11 @@ function registerAdminBridgeCli(api: any) {
           description: "OpenClaw admin bridge commands",
           hasSubcommands: true,
         },
+        {
+          name: "rol-websocket-channel",
+          description: "OpenClaw admin bridge commands",
+          hasSubcommands: true,
+        },
       ],
     },
   );

package/message-handler.ts

@@ -60,7 +60,7 @@ import {
   importMemoryZip,
 } from './src/admin/methods/memory.js';
 import { getMem9Config, installMem9, reconnectMem9 } from './src/admin/methods/mem9.js';
-import { restart, stop, doctorFix, logs } from './src/admin/methods/system.js';
+import { doctorFix, logs, openclawUpdate, pluginSelfUpdate, restart, stop } from './src/admin/methods/system.js';
 
 export class MessageHandler {
   /**
@@ -583,6 +583,20 @@ export class MessageHandler {
     });
   }
 
+  async openclawUpdate(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await openclawUpdate(data, context);
+    });
+  }
+
+  async pluginSelfUpdate(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await pluginSelfUpdate(data, context);
+    });
+  }
+
   /**
    * 示例方法：处理 status 类型的消息
    */

package/openclaw.plugin.json

@@ -4,6 +4,86 @@
   "version": "1.0.0",
   "description": "Unified plugin providing MQTT Channel and Admin Bridge capabilities for OpenClaw management",
   "channels": ["rol-websocket-channel"],
+  "activation": {
+    "onCommands": ["admin-bridge", "rol-websocket-channel"]
+  },
+  "commandAliases": [
+    { "name": "admin-bridge" },
+    { "name": "rol-websocket-channel" }
+  ],
+  "channelConfigs": {
+    "rol-websocket-channel": {
+      "schema": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean"
+          },
+          "pairingEndpoint": {
+            "type": "string"
+          },
+          "mqttUrl": {
+            "type": "string"
+          },
+          "mqttTopic": {
+            "type": "string"
+          },
+          "groupPolicy": {
+            "type": "string",
+            "enum": ["pairing", "allowlist", "open", "disabled"]
+          },
+          "config": {
+            "type": "object",
+            "properties": {
+              "enabled": {
+                "type": "boolean"
+              },
+              "pairingEndpoint": {
+                "type": "string"
+              },
+              "mqttUrl": {
+                "type": "string"
+              },
+              "mqttTopic": {
+                "type": "string"
+              },
+              "groupPolicy": {
+                "type": "string",
+                "enum": ["pairing", "allowlist", "open", "disabled"]
+              }
+            },
+            "additionalProperties": true
+          }
+        },
+        "additionalProperties": true
+      },
+      "uiHints": {
+        "enabled": {
+          "label": "Enabled",
+          "description": "Enable this configuration"
+        },
+        "pairingEndpoint": {
+          "label": "Pairing Endpoint",
+          "description": "Optional pairing API endpoint or base URL for staging/local environments"
+        },
+        "mqttUrl": {
+          "label": "MQTT Broker URL",
+          "placeholder": "ws://192.168.1.152:8083/mqtt",
+          "help": "MQTT broker WebSocket URL (e.g., ws://192.168.1.152:8083/mqtt)"
+        },
+        "mqttTopic": {
+          "label": "MQTT Topic",
+          "placeholder": "announcement/tester",
+          "help": "MQTT topic to subscribe/publish"
+        },
+        "groupPolicy": {
+          "label": "Group Policy",
+          "description": "Message policy for group chats"
+        }
+      }
+    }
+  },
   "cli": ["admin-bridge"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rol-websocket-channel",
-  "version": "1.4.2",
+  "version": "1.4.9",
   "description": "Unified OpenClaw plugin: MQTT Channel + Admin Bridge for remote management",
   "license": "MIT",
   "author": "nixgnehc",

package/src/admin/cli-manifest.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import register from '../../index.js';
+
+const manifest = JSON.parse(readFileSync(new URL('../../openclaw.plugin.json', import.meta.url), 'utf8'));
+
+test('manifest declares OpenClaw 2026 command ownership for admin bridge CLI', () => {
+  assert.deepEqual(manifest.activation?.onCommands, ['admin-bridge', 'rol-websocket-channel']);
+  assert.deepEqual(manifest.commandAliases, [
+    { name: 'admin-bridge' },
+    { name: 'rol-websocket-channel' }
+  ]);
+});
+
+test('runtime CLI registrar exposes admin-bridge and rol-websocket-channel command roots', () => {
+  const descriptors: unknown[] = [];
+  const commands: string[] = [];
+  const aliases: string[] = [];
+  const commandNode = {
+    alias(name: string) {
+      aliases.push(name);
+      return commandNode;
+    },
+    description() {
+      return commandNode;
+    },
+    addHelpText() {
+      return commandNode;
+    },
+    option() {
+      return commandNode;
+    },
+    action() {
+      return commandNode;
+    },
+    command(name: string) {
+      commands.push(name);
+      return commandNode;
+    }
+  };
+  const api = {
+    runtime: {},
+    registerChannel() {},
+    registerCli(callback: (input: { program: typeof commandNode }) => void, options: { descriptors: unknown[] }) {
+      descriptors.push(...options.descriptors);
+      callback({ program: commandNode });
+    }
+  };
+
+  register(api);
+
+  assert.deepEqual(descriptors, [
+    {
+      name: 'admin-bridge',
+      description: 'OpenClaw admin bridge commands',
+      hasSubcommands: true
+    },
+    {
+      name: 'rol-websocket-channel',
+      description: 'OpenClaw admin bridge commands',
+      hasSubcommands: true
+    }
+  ]);
+  assert.equal(commands[0], 'admin-bridge');
+  assert.equal(aliases[0], 'rol-websocket-channel');
+});

package/src/admin/methods/artifacts.test.ts

@@ -107,6 +107,41 @@ describe('artifacts workspace scope', () => {
     );
   });
 
+  test('indexes only markdown files added after the initial baseline', async () => {
+    const context = await createMethodContext();
+    const workspaceRoot = path.join(context.openclawRoot, 'workspace');
+
+    await fs.mkdir(path.join(workspaceRoot, 'docs'), { recursive: true });
+    await fs.writeFile(path.join(workspaceRoot, 'docs', 'existing.md'), '# existing\n', 'utf8');
+    await fs.writeFile(path.join(workspaceRoot, 'MEMORY.md'), '# memory\n', 'utf8');
+    await fs.writeFile(path.join(workspaceRoot, 'SoUL.md'), '# soul\n', 'utf8');
+
+    const baseline = await refreshArtifacts({}, context) as {
+      count: number;
+      items: Array<{ relativePath: string }>;
+    };
+
+    assert.equal(baseline.count, 0);
+    assert.deepEqual(baseline.items, []);
+
+    await fs.writeFile(path.join(workspaceRoot, 'docs', 'existing.md'), '# changed\n', 'utf8');
+    await fs.writeFile(path.join(workspaceRoot, 'MEMORY.md'), '# changed memory\n', 'utf8');
+    await fs.writeFile(path.join(workspaceRoot, 'docs', 'generated.md'), '# generated\n', 'utf8');
+
+    const refreshed = await refreshArtifacts({}, context) as {
+      count: number;
+      items: Array<{ relativePath: string; category: string; mimeType: string }>;
+    };
+
+    assert.equal(refreshed.count, 1);
+    assert.deepEqual(
+      refreshed.items.map((item) => item.relativePath),
+      ['docs/generated.md']
+    );
+    assert.equal(refreshed.items[0]?.category, 'document');
+    assert.equal(refreshed.items[0]?.mimeType, 'text/markdown');
+  });
+
   test('list reads workspace manifest without taskId', async () => {
     const context = await createMethodContext();
     const workspaceRoot = path.join(context.openclawRoot, 'workspace');

package/src/admin/methods/artifacts.ts

@@ -40,6 +40,19 @@ interface ArtifactScanParams {
   refresh?: boolean;
 }
 
+interface MarkdownScanStateFile {
+  sizeBytes: number;
+  mtimeMs: number;
+  firstSeenAt: string;
+  baseline: boolean;
+}
+
+interface MarkdownScanState {
+  initializedAt: string;
+  lastScanAt: string;
+  files: Record<string, MarkdownScanStateFile>;
+}
+
 interface ArtifactGetContentParams {
   artifactId?: string;
   relativePath?: string;
@@ -91,8 +104,19 @@ interface OpenClawConfig {
 const INLINE_CONTENT_LIMIT_BYTES = 10 * 1024 * 1024;
 const MIN_ARTIFACT_SIZE_BYTES = 1;
 const ARTIFACT_MANIFEST_FILE = 'artifacts.json';
+const MARKDOWN_SCAN_STATE_FILE = 'md-scan-state.json';
+const PLUGIN_WORKSPACE_STATE_DIR = path.join('.openclaw', 'rol-websocket-channel');
 const IGNORE_EXTENSIONS = new Set(['.tmp', '.part', '.crdownload']);
 const IGNORE_FILE_NAMES = new Set(['.ds_store', 'thumbs.db', ARTIFACT_MANIFEST_FILE]);
+const IGNORE_MARKDOWN_FILE_NAMES = new Set([
+  'agents.md',
+  'heartbeat.md',
+  'identity.md',
+  'memory.md',
+  'soul.md',
+  'tools.md',
+  'user.md'
+]);
 const IGNORE_DIRECTORY_NAMES = new Set([
   '.git',
   '.cache',
@@ -124,6 +148,7 @@ const CATEGORY_BY_EXTENSION: Record<string, ArtifactCategory> = {
   '.pdf': 'document',
   '.doc': 'document',
   '.docx': 'document',
+  '.md': 'document',
   '.zip': 'archive',
   '.7z': 'archive',
   '.tar': 'archive',
@@ -147,6 +172,7 @@ const MIME_BY_EXTENSION: Record<string, string> = {
   '.pdf': 'application/pdf',
   '.doc': 'application/msword',
   '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.md': 'text/markdown',
   '.zip': 'application/zip',
   '.7z': 'application/x-7z-compressed',
   '.tar': 'application/x-tar',
@@ -157,6 +183,7 @@ const MIME_BY_EXTENSION: Record<string, string> = {
 interface WorkspacePaths {
   workspaceRoot: string;
   manifestPath: string;
+  markdownScanStatePath: string;
 }
 
 interface PresignedPostUploadTarget {
@@ -411,6 +438,9 @@ async function refreshArtifactManifest(
 
   const existing = await readExistingManifest(manifestPath);
   const existingByPath = new Map(existing.map((item) => [item.relativePath, item]));
+  const loadedMarkdownScanState = await readMarkdownScanState(workspacePaths.markdownScanStatePath);
+  const hadMarkdownScanState = loadedMarkdownScanState !== null;
+  const markdownScanState = loadedMarkdownScanState ?? createMarkdownScanState();
   const files = await collectArtifactFiles(workspaceRoot);
   const items: ArtifactRecord[] = [];
 
@@ -423,7 +453,18 @@ async function refreshArtifactManifest(
     const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
     const existingItem = existingByPath.get(relativePath);
     const fileName = path.basename(fullPath);
-    if (!shouldIncludeArtifactFile(fileName)) {
+    const isMarkdown = isMarkdownArtifactFile(fileName);
+    if (isMarkdown) {
+      if (!shouldIncludeMarkdownArtifactFile(
+        relativePath,
+        fileName,
+        stat,
+        markdownScanState,
+        hadMarkdownScanState
+      )) {
+        continue;
+      }
+    } else if (!shouldIncludeArtifactFile(fileName)) {
       continue;
     }
 
@@ -453,6 +494,8 @@ async function refreshArtifactManifest(
   }
 
   items.sort((a, b) => a.fileName.localeCompare(b.fileName));
+  markdownScanState.lastScanAt = new Date().toISOString();
+  await writeMarkdownScanState(workspacePaths.markdownScanStatePath, markdownScanState);
   await writeArtifactManifest(manifestPath, items);
 
   return { manifestPath, items, workspacePaths };
@@ -499,6 +542,37 @@ async function writeArtifactManifest(manifestPath: string, items: ArtifactRecord
   );
 }
 
+async function readMarkdownScanState(statePath: string): Promise<MarkdownScanState | null> {
+  if (!(await pathExists(statePath))) {
+    return null;
+  }
+
+  const parsed = await readJsonFile<JsonValue>(statePath);
+  if (!isObject(parsed)) {
+    return null;
+  }
+
+  const files: Record<string, MarkdownScanStateFile> = {};
+  if (isObject(parsed.files)) {
+    for (const [relativePath, value] of Object.entries(parsed.files)) {
+      if (isMarkdownScanStateFile(value)) {
+        files[relativePath] = value;
+      }
+    }
+  }
+
+  return {
+    initializedAt: typeof parsed.initializedAt === 'string' ? parsed.initializedAt : new Date().toISOString(),
+    lastScanAt: typeof parsed.lastScanAt === 'string' ? parsed.lastScanAt : new Date().toISOString(),
+    files
+  };
+}
+
+async function writeMarkdownScanState(statePath: string, state: MarkdownScanState): Promise<void> {
+  await ensureDir(path.dirname(statePath));
+  await fs.writeFile(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+
 async function persistUploadedArtifact(
   manifestPath: string,
   items: ArtifactRecord[],
@@ -625,12 +699,26 @@ function resolveWorkspaceRoot(openclawRoot: string): string {
 async function ensureWorkspacePaths(openclawRoot: string): Promise<WorkspacePaths> {
   const workspaceRoot = resolveWorkspaceRoot(openclawRoot);
   const manifestPath = ensureInside(workspaceRoot, path.join(workspaceRoot, ARTIFACT_MANIFEST_FILE));
+  const markdownScanStatePath = ensureInside(
+    workspaceRoot,
+    path.join(workspaceRoot, PLUGIN_WORKSPACE_STATE_DIR, MARKDOWN_SCAN_STATE_FILE)
+  );
 
   await ensureDir(workspaceRoot);
 
   return {
     workspaceRoot,
-    manifestPath
+    manifestPath,
+    markdownScanStatePath
+  };
+}
+
+function createMarkdownScanState(): MarkdownScanState {
+  const now = new Date().toISOString();
+  return {
+    initializedAt: now,
+    lastScanAt: now,
+    files: {}
   };
 }
 
@@ -643,6 +731,10 @@ function normalizeExtension(fileName: string): string | null {
   return ext || null;
 }
 
+function isMarkdownArtifactFile(fileName: string): boolean {
+  return path.extname(fileName).toLowerCase() === '.md';
+}
+
 function normalizeRelativePath(value: string | null): string | null {
   if (!value) {
     return null;
@@ -687,6 +779,52 @@ function shouldIncludeArtifactFile(fileName: string): boolean {
   return classifyArtifactCategory(fileName) !== 'other';
 }
 
+function shouldIncludeMarkdownArtifactFile(
+  relativePath: string,
+  fileName: string,
+  stat: { size: number; mtimeMs: number },
+  state: MarkdownScanState,
+  hadState: boolean
+): boolean {
+  if (shouldIgnoreArtifactFile(fileName)) {
+    return false;
+  }
+
+  if (IGNORE_MARKDOWN_FILE_NAMES.has(fileName.trim().toLowerCase())) {
+    return false;
+  }
+
+  const existing = state.files[relativePath];
+  if (existing) {
+    existing.sizeBytes = stat.size;
+    existing.mtimeMs = stat.mtimeMs;
+    return !existing.baseline;
+  }
+
+  state.files[relativePath] = {
+    sizeBytes: stat.size,
+    mtimeMs: stat.mtimeMs,
+    firstSeenAt: new Date().toISOString(),
+    baseline: !hadState
+  };
+
+  return hadState;
+}
+
+function isMarkdownScanStateFile(value: unknown): value is MarkdownScanStateFile {
+  if (!value || Array.isArray(value) || typeof value !== 'object') {
+    return false;
+  }
+
+  const objectValue = value as Record<string, unknown>;
+  return (
+    typeof objectValue.sizeBytes === 'number' &&
+    typeof objectValue.mtimeMs === 'number' &&
+    typeof objectValue.firstSeenAt === 'string' &&
+    typeof objectValue.baseline === 'boolean'
+  );
+}
+
 function isArtifactRecord(value: unknown): value is ArtifactRecord {
   if (!value || Array.isArray(value) || typeof value !== 'object') {
     return false;

package/src/admin/methods/index.ts

@@ -48,7 +48,7 @@ import {
   updateSkillFromClawHub
 } from './skills.js';
 import { getInstalledSkill, uninstallSkill } from './skills-extended.js';
-import { ping, restart, stop, doctorFix, logs } from './system.js';
+import { doctorFix, logs, openclawUpdate, ping, pluginSelfUpdate, restart, stop } from './system.js';
 import {
   getUsageBreakdown,
   getUsagePageSummary,
@@ -63,6 +63,8 @@ const methods = new Map<string, MethodHandler>([
   ['system.stop', stop],
   ['system.doctorFix', doctorFix],
   ['system.logs', logs],
+  ['system.openclawUpdate', openclawUpdate],
+  ['system.pluginSelfUpdate', pluginSelfUpdate],
   
   // Agents
   ['agents.get', getAgents],

package/src/admin/methods/mem9.test.ts

@@ -0,0 +1,39 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { findMem9RuntimeEntrypoint } from './mem9.js';
+
+describe('mem9 runtime compatibility', () => {
+  test('accepts compiled runtime output under the installed package', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+      await fs.mkdir(path.join(packageRoot, 'dist'), { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'dist', 'index.js'), 'export default {};\n', 'utf8');
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, path.join(packageRoot, 'dist', 'index.js'));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('rejects TypeScript-only mem9 packages before writing memory slot', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+      await fs.mkdir(packageRoot, { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'index.ts'), 'export default {};\n', 'utf8');
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, null);
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/admin/methods/mem9.ts

@@ -13,6 +13,18 @@ const MEM9_PLUGIN_ID = 'mem9';
 const MEM9_API_URL = 'https://api.mem9.ai';
 const MEM9_CREATE_URL = `${MEM9_API_URL}/v1alpha1/mem9s`;
 const GATEWAY_SERVICE = 'openclaw-gateway.service';
+const MEM9_PACKAGE_ROOTS = [
+  path.join('npm', 'node_modules', '@mem9', 'mem9'),
+  path.join('npm', 'node_modules', 'mem9')
+];
+const RUNTIME_ENTRYPOINTS = [
+  path.join('dist', 'index.js'),
+  path.join('dist', 'index.mjs'),
+  path.join('dist', 'index.cjs'),
+  'index.js',
+  'index.mjs',
+  'index.cjs'
+];
 
 interface OpenClawConfig {
   plugins?: {
@@ -30,9 +42,11 @@ export async function installMem9(context: MethodContext): Promise<JsonValue> {
   await ensureNodeRuntime();
 
   const currentState = readMem9State(config);
-  const installResult = currentState.installed
+  const currentEntrypoint = await findMem9RuntimeEntrypoint(context.openclawRoot);
+  const installResult = currentState.installed && currentEntrypoint
     ? { attempted: false, installed: true }
     : await installMem9Plugin(context.projectRoot);
+  const runtimeEntrypoint = await ensureMem9RuntimeEntrypoint(context.openclawRoot);
 
   if (currentState.configured && currentState.apiKey) {
     const updated = await ensureMem9SlotConfig(context.openclawRoot, currentState.apiKey);
@@ -46,6 +60,7 @@ export async function installMem9(context: MethodContext): Promise<JsonValue> {
       createdNewKey: false,
       reusedExistingKey: true,
       plugin: MEM9_PLUGIN_ID,
+      runtimeEntrypoint,
       apiUrl: MEM9_API_URL,
       apiKey: currentState.apiKey,
       updated,
@@ -65,6 +80,7 @@ export async function installMem9(context: MethodContext): Promise<JsonValue> {
     createdNewKey: true,
     reusedExistingKey: false,
     plugin: MEM9_PLUGIN_ID,
+    runtimeEntrypoint,
     apiUrl: MEM9_API_URL,
     apiKey,
     updated,
@@ -80,6 +96,7 @@ export async function reconnectMem9(key: string, context: MethodContext): Promis
 
   const config = await ensureOpenClawConfigExists(context.openclawRoot);
   const previousState = readMem9State(config);
+  const runtimeEntrypoint = await ensureMem9RuntimeEntrypoint(context.openclawRoot);
   const updated = await writeMem9Config(context.openclawRoot, apiKey);
   const restart = await restartGateway(context.projectRoot);
 
@@ -88,6 +105,7 @@ export async function reconnectMem9(key: string, context: MethodContext): Promis
     reconnected: true,
     replacedExistingKey: Boolean(previousState.apiKey && previousState.apiKey !== apiKey),
     plugin: MEM9_PLUGIN_ID,
+    runtimeEntrypoint,
     apiUrl: MEM9_API_URL,
     apiKey,
     updated: ['plugins.entries.mem9.config.apiKey', ...updated.filter((item) => item !== 'plugins.entries.mem9' && item !== 'plugins.slots.memory')],
@@ -171,6 +189,35 @@ async function installMem9Plugin(cwd: string): Promise<{ attempted: boolean; ins
   };
 }
 
+export async function findMem9RuntimeEntrypoint(openclawRoot: string): Promise<string | null> {
+  for (const packageRoot of MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))) {
+    for (const entrypoint of RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))) {
+      if (await pathExists(entrypoint)) {
+        return entrypoint;
+      }
+    }
+  }
+
+  return null;
+}
+
+async function ensureMem9RuntimeEntrypoint(openclawRoot: string): Promise<string> {
+  const entrypoint = await findMem9RuntimeEntrypoint(openclawRoot);
+  if (entrypoint) {
+    return entrypoint;
+  }
+
+  throw new JsonRpcException(
+    JSON_RPC_ERRORS.internalError,
+    'mem9 plugin is installed but missing compiled runtime output required by OpenClaw 2026.5.6',
+    {
+      code: 'MEM9_RUNTIME_OUTPUT_MISSING',
+      expected: RUNTIME_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
+      packageRoots: MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))
+    }
+  );
+}
+
 async function createMem9Key(): Promise<string> {
   const response = await fetch(MEM9_CREATE_URL, {
     method: 'POST',