rol-websocket-channel 1.4.2 → 1.4.8

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

@@ -1,191 +1,210 @@
-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 { ensureArtifactUploaded, listArtifacts, markArtifactUploaded, refreshArtifacts } from './artifacts.js';
-const tempDirs = [];
-const originalFetch = globalThis.fetch;
-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('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');
-    });
-});
-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');
-}
+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 { ensureArtifactUploaded, listArtifacts, markArtifactUploaded, refreshArtifacts } from './artifacts.js';
+const tempDirs = [];
+const originalFetch = globalThis.fetch;
+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');
+    });
+});
+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');
+}