rol-websocket-channel 1.7.4 → 1.7.6

package/src/admin/methods/sessions-extended.ts

@@ -26,9 +26,10 @@ export const getSession: MethodHandler = async (
     : undefined;
   const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
   const requestedLimit = typeof objectParams.limit === 'number' ? objectParams.limit : MAX_SESSION_MESSAGES;
-  const requestedOffset = typeof objectParams.offset === 'number' ? objectParams.offset : 0;
+  const beforeId = typeof objectParams.beforeId === 'string' && objectParams.beforeId.trim()
+    ? objectParams.beforeId.trim()
+    : undefined;
   const limit = normalizePageSize(requestedLimit, MAX_SESSION_MESSAGES);
-  const offset = normalizeOffset(requestedOffset);
 
   if (!sessionId) {
     throw new JsonRpcException(
@@ -52,7 +53,7 @@ export const getSession: MethodHandler = async (
     'sessions',
     `${session.sessionId ?? sessionId}.jsonl`
   );
-  const messages = await readSessionMessages(sessionFile, limit, offset);
+  const messages = await readSessionMessages(sessionFile, limit, beforeId);
 
   return {
     agentId: session.agentId,
@@ -69,7 +70,8 @@ export const getSession: MethodHandler = async (
     messages: {
       total: messages.total,
       limit,
-      offset,
+      hasMore: messages.hasMore,
+      nextBeforeId: messages.nextBeforeId,
       items: messages.items
     }
   };
@@ -203,21 +205,13 @@ function normalizePageSize(value: number, max: number): number {
   return Math.min(normalized, max);
 }
 
-function normalizeOffset(value: number): number {
-  if (!Number.isFinite(value)) {
-    return 0;
-  }
-
-  return Math.max(0, Math.floor(value));
-}
-
 async function readSessionMessages(
   filePath: string,
   limit: number,
-  offset: number
-): Promise<{ total: number; items: SessionMessage[] }> {
+  beforeId?: string
+): Promise<{ total: number; hasMore: boolean; nextBeforeId: string | null; items: SessionMessage[] }> {
   if (!(await pathExists(filePath))) {
-    return { total: 0, items: [] };
+    return { total: 0, hasMore: false, nextBeforeId: null, items: [] };
   }
 
   const messages: SessionMessage[] = [];
@@ -239,9 +233,24 @@ async function readSessionMessages(
     }
   }
 
+  const endExclusive = beforeId ? messages.findIndex((message) => message.id === beforeId) : messages.length;
+  if (endExclusive < 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `beforeId not found: ${beforeId}`
+    );
+  }
+
+  const start = Math.max(0, endExclusive - limit);
+  const items = messages.slice(start, endExclusive);
+  const hasMore = start > 0;
+  const firstItemId = typeof items[0]?.id === 'string' ? items[0].id : null;
+
   return {
     total: messages.length,
-    items: messages.slice(offset, offset + limit)
+    hasMore,
+    nextBeforeId: hasMore ? firstItemId : null,
+    items
   };
 }
 

package/tsconfig.json

@@ -13,5 +13,5 @@
     "rootDir": "."
   },
   "include": ["index.ts", "src/**/*.ts", "types/**/*.d.ts"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "test", "**/*.test.ts", "**/*.spec.ts"]
 }

package/dist/src/admin/cli-manifest.test.js

@@ -1,122 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import test from 'node:test';
-import entry, { formatCliErrorPayload } from '../../index.js';
-const manifest = JSON.parse(readFileSync(new URL('../../openclaw.plugin.json', import.meta.url), 'utf8'));
-const packageJson = JSON.parse(readFileSync(new URL('../../package.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' }
-    ]);
-    assert.deepEqual(manifest.contracts?.tools, [
-        'rol_artifacts_find_latest',
-        'rol_artifacts_publish'
-    ]);
-});
-test('package.json declares official OpenClaw runtime metadata', () => {
-    assert.deepEqual(packageJson.openclaw?.extensions, ['./index.ts']);
-    assert.deepEqual(packageJson.openclaw?.runtimeExtensions, ['./dist/index.js']);
-    assert.deepEqual(packageJson.openclaw?.compat, {
-        pluginApi: '>=2026.5.7',
-        minGatewayVersion: '2026.5.7'
-    });
-    assert.deepEqual(packageJson.openclaw?.build, {
-        openclawVersion: '2026.5.7',
-        pluginSdkVersion: '2026.5.7'
-    });
-});
-test('runtime entry exposes admin-bridge CLI roots and registers artifacts tools in full mode', () => {
-    const descriptors = [];
-    const commands = [];
-    const aliases = [];
-    const registeredTools = [];
-    const commandNode = {
-        alias(name) {
-            aliases.push(name);
-            return commandNode;
-        },
-        description() {
-            return commandNode;
-        },
-        addHelpText() {
-            return commandNode;
-        },
-        option() {
-            return commandNode;
-        },
-        action() {
-            return commandNode;
-        },
-        command(name) {
-            commands.push(name);
-            return commandNode;
-        }
-    };
-    const api = {
-        registrationMode: 'full',
-        runtime: {},
-        registerChannel() { },
-        registerTool(tool) {
-            registeredTools.push(tool);
-        },
-        registerCli(callback, options) {
-            descriptors.push(...options.descriptors);
-            callback({ program: commandNode });
-        }
-    };
-    entry.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');
-    assert.equal(registeredTools.length, 1);
-});
-test('CLI metadata mode skips full-only tool registration', () => {
-    let registerToolCalled = false;
-    const api = {
-        registrationMode: 'cli-metadata',
-        runtime: {},
-        registerChannel() { },
-        registerTool() {
-            registerToolCalled = true;
-        },
-        registerCli() { }
-    };
-    entry.register(api);
-    assert.equal(registerToolCalled, false);
-});
-test('CLI error formatter preserves diagnostic data for pairing failures', () => {
-    const error = new Error('mqttUrl is missing from pairing payload');
-    error.data = {
-        code: 'PAIR_CHANNEL_CONFIG_INVALID',
-        debug: {
-            rootKeys: ['channel'],
-            channelConfigKeys: ['mqtt_topic'],
-            hasExistingMqttUrl: false
-        }
-    };
-    assert.deepEqual(formatCliErrorPayload(error), {
-        ok: false,
-        error: {
-            message: 'mqttUrl is missing from pairing payload',
-            code: 'PAIR_CHANNEL_CONFIG_INVALID',
-            debug: {
-                rootKeys: ['channel'],
-                channelConfigKeys: ['mqtt_topic'],
-                hasExistingMqttUrl: false
-            }
-        }
-    });
-});

package/dist/src/admin/lib/openclaw-bin.test.js

@@ -1,37 +0,0 @@
-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 { resolveOpenClawBin } from './openclaw-bin.js';
-describe('resolveOpenClawBin', () => {
-    test('uses APPDATA npm shim on Windows when OPENCLAW_BIN is unset', { skip: process.platform !== 'win32' }, async () => {
-        const originalOpenClawBin = process.env.OPENCLAW_BIN;
-        const originalAppData = process.env.APPDATA;
-        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'openclaw-bin-'));
-        try {
-            const appData = path.join(root, 'Roaming');
-            const shim = path.join(appData, 'npm', 'openclaw.cmd');
-            await fs.mkdir(path.dirname(shim), { recursive: true });
-            await fs.writeFile(shim, '@echo off\r\n', 'utf8');
-            delete process.env.OPENCLAW_BIN;
-            process.env.APPDATA = appData;
-            assert.equal(resolveOpenClawBin(), shim);
-        }
-        finally {
-            if (originalOpenClawBin === undefined) {
-                delete process.env.OPENCLAW_BIN;
-            }
-            else {
-                process.env.OPENCLAW_BIN = originalOpenClawBin;
-            }
-            if (originalAppData === undefined) {
-                delete process.env.APPDATA;
-            }
-            else {
-                process.env.APPDATA = originalAppData;
-            }
-            await fs.rm(root, { recursive: true, force: true });
-        }
-    });
-});

package/dist/src/admin/methods/admin.test.js

@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { setApiCoreBotConfig } from './admin.js';
-test('setApiCoreBotConfig writes apiCoreBot endpoint without changing pairing or channel config', async () => {
-    const context = await createMethodContext();
-    const configPath = path.join(context.openclawRoot, 'openclaw.json');
-    await fs.writeFile(configPath, JSON.stringify({
-        plugins: {
-            entries: {
-                'rol-websocket-channel': {
-                    enabled: true,
-                    config: {
-                        pairing: {
-                            paired: true,
-                            pairingKeyLast4: '7a46'
-                        }
-                    }
-                }
-            }
-        },
-        channels: {
-            'rol-websocket-channel': {
-                enabled: true,
-                config: {
-                    mqttUrl: 'ws://mqtt.example.test:8083/mqtt'
-                }
-            }
-        }
-    }, null, 2));
-    const result = await setApiCoreBotConfig({
-        baseUrl: 'https://api.example.test/',
-        authToken: 'secret-token'
-    }, context);
-    const savedConfig = JSON.parse(await fs.readFile(configPath, 'utf8'));
-    assert.equal(result.ok, true);
-    assert.equal(result.apiCoreBot.baseUrl, 'https://api.example.test');
-    assert.equal(result.apiCoreBot.authToken, 'secr***oken');
-    assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.baseUrl, 'https://api.example.test');
-    assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.authToken, 'secret-token');
-    assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.pairing.pairingKeyLast4, '7a46');
-    assert.equal(savedConfig.channels['rol-websocket-channel'].config.mqttUrl, 'ws://mqtt.example.test:8083/mqtt');
-});
-test('setApiCoreBotConfig rejects missing baseUrl instead of writing defaults', async () => {
-    const context = await createMethodContext();
-    const configPath = path.join(context.openclawRoot, 'openclaw.json');
-    await fs.writeFile(configPath, '{}');
-    await assert.rejects(() => setApiCoreBotConfig({}, context), /apiCoreBot\.baseUrl is required/);
-    assert.equal(await fs.readFile(configPath, 'utf8'), '{}');
-});
-async function createMethodContext() {
-    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'api-core-bot-config-test-'));
-    const openclawRoot = path.join(projectRoot, '.openclaw');
-    await fs.mkdir(openclawRoot, { recursive: true });
-    return {
-        projectRoot,
-        openclawRoot
-    };
-}

package/dist/src/admin/methods/artifacts.test.js

@@ -1,304 +0,0 @@
-import { afterEach, 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 * as artifactMethods from './artifacts.js';
-import { ensureArtifactUploaded, listArtifacts, markArtifactUploaded, refreshArtifacts } from './artifacts.js';
-const tempDirs = [];
-const originalFetch = globalThis.fetch;
-const optionalArtifactMethods = artifactMethods;
-afterEach(async () => {
-    globalThis.fetch = originalFetch;
-    while (tempDirs.length > 0) {
-        const dir = tempDirs.pop();
-        if (dir) {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-    }
-});
-describe('artifacts workspace scope', () => {
-    test('only indexes allowed artifact types inside workspace', async () => {
-        const context = await createMethodContext();
-        const workspaceRoot = path.join(context.openclawRoot, 'workspace');
-        await fs.writeFile(path.join(workspaceRoot, 'SOUL.md'), '# root noise\n', 'utf8');
-        await fs.mkdir(path.join(workspaceRoot, 'exports'), { recursive: true });
-        await fs.mkdir(path.join(workspaceRoot, 'logs'), { recursive: true });
-        await fs.mkdir(path.join(workspaceRoot, 'nested', 'media'), { recursive: true });
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'preview.png'), 'png-data', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'report.pdf'), 'pdf-data', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'nested', 'media', 'archive.zip'), 'zip-data', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'nested', 'media', 'video.mp4'), 'mp4-data', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'spec.docx'), 'docx-data', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'ignored.md'), '# markdown noise\n', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'ignored.json'), '{"noise":true}\n', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'logs', 'ignored.pdf'), 'log pdf noise', 'utf8');
-        await fs.writeFile(path.join(workspaceRoot, 'artifacts.json'), '[]', 'utf8');
-        const result = await refreshArtifacts({}, context);
-        assert.equal(result.scope, 'workspace');
-        assert.equal(result.count, 5);
-        assert.deepEqual(result.items.map((item) => item.relativePath), [
-            'nested/media/archive.zip',
-            'exports/preview.png',
-            'exports/report.pdf',
-            'exports/spec.docx',
-            'nested/media/video.mp4'
-        ]);
-        assert.equal(result.workspaceRoot, workspaceRoot);
-        assert.equal(result.manifestPath, path.join(workspaceRoot, 'artifacts.json'));
-    });
-    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);
-        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);
-        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');
-        await fs.mkdir(path.join(workspaceRoot, 'exports'), { recursive: true });
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'me.pdf'), 'pdf-data', 'utf8');
-        const refreshed = await refreshArtifacts({}, context);
-        assert.equal(refreshed.count, 1);
-        const listed = await listArtifacts({ refresh: false }, context);
-        assert.equal(listed.scope, 'workspace');
-        assert.equal(listed.count, 1);
-        assert.deepEqual(listed.items.map((item) => item.relativePath), ['exports/me.pdf']);
-        assert.equal(listed.manifestPath, path.join(workspaceRoot, 'artifacts.json'));
-        assert.equal(listed.workspaceRoot, workspaceRoot);
-    });
-    test('ensureUploaded uploads local artifact and updates manifest', async () => {
-        const context = await createMethodContext();
-        const workspaceRoot = path.join(context.openclawRoot, 'workspace');
-        const artifactPath = path.join(workspaceRoot, 'exports', 'me.pdf');
-        await writeApiCoreBotConfig(context.openclawRoot, 'https://api.example.com');
-        await fs.mkdir(path.dirname(artifactPath), { recursive: true });
-        await fs.writeFile(artifactPath, 'pdf-data', 'utf8');
-        const refreshed = await refreshArtifacts({}, context);
-        const artifactId = refreshed.items[0]?.id;
-        assert.ok(artifactId);
-        const calls = [];
-        globalThis.fetch = (async (input, init) => {
-            const url = typeof input === 'string'
-                ? input
-                : input instanceof URL
-                    ? input.toString()
-                    : input.url;
-            const method = init?.method ?? (input instanceof Request ? input.method : 'GET');
-            calls.push({ url, method });
-            if (url === 'https://api.example.com/api-core-bot/front/s3/get-presigned-post') {
-                assert.equal(init?.body !== undefined, true);
-                const parsedBody = JSON.parse(String(init?.body));
-                assert.equal(parsedBody.dir, 'artifacts/');
-                assert.equal(parsedBody.filename, 'me.pdf');
-                assert.equal(parsedBody.file_name, undefined);
-                return new Response(JSON.stringify({
-                    code: 0,
-                    message: '',
-                    success: true,
-                    data: {
-                        url: 'https://upload.example.com',
-                        fields: {
-                            key: 'artifacts/me.pdf',
-                            policy: 'policy-token'
-                        },
-                        file_key: 'artifacts/me.pdf',
-                        file_url: 'https://cdn.example.com/artifacts/me.pdf'
-                    }
-                }), {
-                    status: 200,
-                    headers: { 'Content-Type': 'application/json' }
-                });
-            }
-            if (url === 'https://upload.example.com') {
-                assert.ok(init?.body instanceof FormData);
-                return new Response(null, { status: 204 });
-            }
-            throw new Error(`Unexpected fetch call: ${url}`);
-        });
-        const ensured = await ensureArtifactUploaded({
-            artifactId,
-            presignedPostBody: {
-                dir: 'artifacts/'
-            }
-        }, context);
-        assert.equal(ensured.ok, true);
-        assert.equal(ensured.uploaded, true);
-        assert.equal(ensured.downloadUrl, 'https://cdn.example.com/artifacts/me.pdf');
-        assert.equal(ensured.objectKey, 'artifacts/me.pdf');
-        assert.equal(ensured.item.storageStatus, 'uploaded');
-        assert.equal(ensured.item.fileUrl, 'https://cdn.example.com/artifacts/me.pdf');
-        assert.equal(ensured.item.objectKey, 'artifacts/me.pdf');
-        assert.deepEqual(calls, [
-            {
-                url: 'https://api.example.com/api-core-bot/front/s3/get-presigned-post',
-                method: 'POST'
-            },
-            {
-                url: 'https://upload.example.com',
-                method: 'POST'
-            }
-        ]);
-        const listed = await listArtifacts({ refresh: false }, context);
-        assert.equal(listed.items.length, 1);
-        assert.equal(listed.items[0]?.relativePath, 'exports/me.pdf');
-        assert.equal(listed.items[0]?.storageStatus, 'uploaded');
-        assert.equal(listed.items[0]?.fileUrl, 'https://cdn.example.com/artifacts/me.pdf');
-        assert.equal(listed.items[0]?.objectKey, 'artifacts/me.pdf');
-    });
-    test('ensureUploaded reuses existing uploaded artifact without fetching', async () => {
-        const context = await createMethodContext();
-        const workspaceRoot = path.join(context.openclawRoot, 'workspace');
-        const artifactPath = path.join(workspaceRoot, 'exports', 'me.pdf');
-        await fs.mkdir(path.dirname(artifactPath), { recursive: true });
-        await fs.writeFile(artifactPath, 'pdf-data', 'utf8');
-        const refreshed = await refreshArtifacts({}, context);
-        const artifactId = refreshed.items[0]?.id;
-        assert.ok(artifactId);
-        await markArtifactUploaded({
-            artifactId,
-            objectKey: 'artifacts/me.pdf',
-            fileUrl: 'https://cdn.example.com/artifacts/me.pdf'
-        }, context);
-        globalThis.fetch = (async () => {
-            throw new Error('fetch should not be called for existing uploaded artifact');
-        });
-        const ensured = await ensureArtifactUploaded({ artifactId }, context);
-        assert.equal(ensured.ok, true);
-        assert.equal(ensured.uploaded, false);
-        assert.equal(ensured.downloadUrl, 'https://cdn.example.com/artifacts/me.pdf');
-        assert.equal(ensured.item.storageStatus, 'uploaded');
-        assert.equal(ensured.item.fileUrl, 'https://cdn.example.com/artifacts/me.pdf');
-    });
-    test('findLatest returns newest matching artifacts with filters', async () => {
-        const findLatestArtifacts = optionalArtifactMethods.findLatestArtifacts;
-        if (!findLatestArtifacts) {
-            return;
-        }
-        const context = await createMethodContext();
-        const workspaceRoot = path.join(context.openclawRoot, 'workspace');
-        await fs.mkdir(path.join(workspaceRoot, 'exports'), { recursive: true });
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'first.pdf'), 'pdf-data', 'utf8');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'second.png'), 'png-data', 'utf8');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        await fs.writeFile(path.join(workspaceRoot, 'exports', 'third.docx'), 'docx-data', 'utf8');
-        const latest = await findLatestArtifacts({
-            category: 'document',
-            relativePathPrefix: 'exports/',
-            limit: 2
-        }, context);
-        assert.equal(latest.ok, true);
-        assert.equal(latest.count, 2);
-        assert.deepEqual(latest.items.map((item) => item.fileName), ['third.docx', 'first.pdf']);
-        assert.deepEqual(latest.items.map((item) => item.category), ['document', 'document']);
-        assert.deepEqual(latest.items.map((item) => item.relativePath), ['exports/third.docx', 'exports/first.pdf']);
-    });
-    test('publish refreshes manifest for a new file and uploads it by relativePath', async () => {
-        const publishArtifact = optionalArtifactMethods.publishArtifact;
-        if (!publishArtifact) {
-            return;
-        }
-        const context = await createMethodContext();
-        const workspaceRoot = path.join(context.openclawRoot, 'workspace');
-        const artifactPath = path.join(workspaceRoot, 'generated', 'result.pdf');
-        await writeApiCoreBotConfig(context.openclawRoot, 'https://api.example.com');
-        await fs.mkdir(path.dirname(artifactPath), { recursive: true });
-        await fs.writeFile(artifactPath, 'pdf-data', 'utf8');
-        const calls = [];
-        globalThis.fetch = (async (input, init) => {
-            const url = typeof input === 'string'
-                ? input
-                : input instanceof URL
-                    ? input.toString()
-                    : input.url;
-            const method = init?.method ?? (input instanceof Request ? input.method : 'GET');
-            calls.push({ url, method });
-            if (url === 'https://api.example.com/api-core-bot/front/s3/get-presigned-post') {
-                const parsedBody = JSON.parse(String(init?.body));
-                assert.equal(parsedBody.filename, 'result.pdf');
-                assert.equal(parsedBody.dir, 'generated/');
-                return new Response(JSON.stringify({
-                    success: true,
-                    data: {
-                        url: 'https://upload.example.com',
-                        fields: {
-                            key: 'generated/result.pdf',
-                            policy: 'policy-token'
-                        },
-                        file_url: 'https://cdn.example.com/generated/result.pdf'
-                    }
-                }), {
-                    status: 200,
-                    headers: { 'Content-Type': 'application/json' }
-                });
-            }
-            if (url === 'https://upload.example.com') {
-                assert.ok(init?.body instanceof FormData);
-                return new Response(null, { status: 204 });
-            }
-            throw new Error(`Unexpected fetch call: ${url}`);
-        });
-        const published = await publishArtifact({
-            relativePath: 'generated/result.pdf',
-            presignedPostBody: {
-                dir: 'generated/'
-            }
-        }, context);
-        assert.equal(published.ok, true);
-        assert.equal(published.uploaded, true);
-        assert.equal(published.downloadUrl, 'https://cdn.example.com/generated/result.pdf');
-        assert.equal(published.item.relativePath, 'generated/result.pdf');
-        assert.equal(published.item.storageStatus, 'uploaded');
-        assert.match(published.artifactId, /^art_/);
-        assert.deepEqual(calls, [
-            {
-                url: 'https://api.example.com/api-core-bot/front/s3/get-presigned-post',
-                method: 'POST'
-            },
-            {
-                url: 'https://upload.example.com',
-                method: 'POST'
-            }
-        ]);
-    });
-});
-async function createMethodContext() {
-    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'artifacts-task-scope-'));
-    tempDirs.push(rootDir);
-    const openclawRoot = path.join(rootDir, '.openclaw');
-    const workspaceRoot = path.join(openclawRoot, 'workspace');
-    await fs.mkdir(workspaceRoot, { recursive: true });
-    return {
-        projectRoot: rootDir,
-        openclawRoot
-    };
-}
-async function writeApiCoreBotConfig(openclawRoot, baseUrl) {
-    await fs.writeFile(path.join(openclawRoot, 'openclaw.json'), JSON.stringify({
-        plugins: {
-            entries: {
-                'rol-websocket-channel': {
-                    config: {
-                        apiCoreBot: {
-                            baseUrl
-                        }
-                    }
-                }
-            }
-        }
-    }, null, 2), 'utf8');
-}

package/dist/src/admin/methods/index.test.js

@@ -1,27 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import * as artifactMethods from './artifacts.js';
-import { setApiCoreBotConfig } from './admin.js';
-import { getMethod, listMethods } from './index.js';
-import { currentVersion } from './system.js';
-test('methods registry exposes local artifact discovery and publish methods', () => {
-    const optionalArtifactMethods = artifactMethods;
-    if (optionalArtifactMethods.findLatestArtifacts) {
-        assert.equal(getMethod('artifacts.findLatest'), optionalArtifactMethods.findLatestArtifacts);
-        assert.ok(listMethods().includes('artifacts.findLatest'));
-    }
-    if (optionalArtifactMethods.publishArtifact) {
-        assert.equal(getMethod('artifacts.publish'), optionalArtifactMethods.publishArtifact);
-        assert.ok(listMethods().includes('artifacts.publish'));
-    }
-});
-test('methods registry exposes apiCoreBot config writer', () => {
-    assert.equal(getMethod('config.setApiCoreBot'), setApiCoreBotConfig);
-    assert.ok(listMethods().includes('config.setApiCoreBot'));
-});
-test('methods registry exposes current version method', () => {
-    assert.equal(getMethod('system.currentVersion'), currentVersion);
-    assert.ok(listMethods().includes('system.currentVersion'));
-    assert.ok(!listMethods().includes('system.ensureLatest'));
-    assert.ok(!listMethods().includes('config.setVersionManagement'));
-});