@jhytabest/plashboard 1.0.0 → 1.0.2

package/README.md

@@ -77,6 +77,12 @@ Add to `openclaw.json`:
 `fill_provider: "command"` requires explicit opt-in with `allow_command_fill: true`.
 Use command mode only if you need a custom external runner.
 
+OpenClaw fill sessions are always cleaned through official Gateway API calls:
+- Pre-run: `openclaw gateway call sessions.reset --params '{"key":"agent:<fill_agent_id>:main","reason":"new"}'`
+- Post-run: same reset call as best-effort cleanup.
+
+This keeps fill runs stateless without editing OpenClaw session files directly.
+
 For production stability, use a dedicated fill agent instead of `main`:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhytabest/plashboard",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "description": "Plashboard OpenClaw plugin runtime",
   "license": "MIT",

package/src/fill-runner.test.ts

@@ -68,20 +68,38 @@ function context(): FillRunContext {
 }
 
 describe('createFillRunner', () => {
-  it('parses openclaw json envelope output', async () => {
-    const commandRunner = vi.fn(async (_argv: string[], _options: unknown) => ({
-      stdout: JSON.stringify({
-        result: {
-          payloads: [
-            {
-              text: '{"values":{"summary":"new summary"}}'
+  it('always resets fill session before and after openclaw fill', async () => {
+    const calls: string[][] = [];
+    const commandRunner = vi.fn(async (argv: string[], _options: unknown) => {
+      calls.push(argv);
+      if (argv[0] === 'openclaw' && argv[1] === 'gateway' && argv[2] === 'call' && argv[3] === 'sessions.reset') {
+        return {
+          stdout: '{"ok":true}',
+          stderr: '',
+          code: 0
+        };
+      }
+      if (argv[0] === 'openclaw' && argv[1] === 'agent') {
+        return {
+          stdout: JSON.stringify({
+            result: {
+              payloads: [
+                {
+                  text: '{"values":{"summary":"new summary"}}'
+                }
+              ]
             }
-          ]
-        }
-      }),
-      stderr: '',
-      code: 0
-    }));
+          }),
+          stderr: '',
+          code: 0
+        };
+      }
+      return {
+        stdout: '',
+        stderr: `unsupported command: ${argv.join(' ')}`,
+        code: 1
+      };
+    });
 
     const runner = createFillRunner(
       config({ fill_provider: 'openclaw', openclaw_fill_agent_id: 'ops' }),
@@ -90,12 +108,98 @@ describe('createFillRunner', () => {
     const response = await runner.run(context());
 
     expect(response.values.summary).toBe('new summary');
+    expect(commandRunner).toHaveBeenCalledTimes(3);
+
+    const [firstCall, secondCall, thirdCall] = calls;
+    expect(firstCall.slice(0, 4)).toEqual(['openclaw', 'gateway', 'call', 'sessions.reset']);
+    expect(secondCall.slice(0, 2)).toEqual(['openclaw', 'agent']);
+    expect(thirdCall.slice(0, 4)).toEqual(['openclaw', 'gateway', 'call', 'sessions.reset']);
+
+    expect(secondCall).toContain('--agent');
+    expect(secondCall).toContain('ops');
+    expect(secondCall).not.toContain('--session-id');
+
+    for (const resetCall of [firstCall, thirdCall]) {
+      const paramsIndex = resetCall.indexOf('--params');
+      expect(paramsIndex).toBeGreaterThan(-1);
+      const params = JSON.parse(resetCall[paramsIndex + 1]) as { key?: string; reason?: string };
+      expect(params.key).toBe('agent:ops:main');
+      expect(params.reason).toBe('new');
+    }
+  });
+
+  it('fails fill when pre-run session reset fails', async () => {
+    const commandRunner = vi.fn(async (argv: string[], _options: unknown) => {
+      if (argv[0] === 'openclaw' && argv[1] === 'gateway' && argv[2] === 'call' && argv[3] === 'sessions.reset') {
+        return {
+          stdout: '',
+          stderr: 'reset failed',
+          code: 1
+        };
+      }
+      return {
+        stdout: '',
+        stderr: `unsupported command: ${argv.join(' ')}`,
+        code: 1
+      };
+    });
+
+    const runner = createFillRunner(
+      config({
+        fill_provider: 'openclaw',
+        openclaw_fill_agent_id: 'ops'
+      }),
+      { commandRunner }
+    );
+
+    await expect(runner.run(context())).rejects.toThrow(/session reset failed/i);
     expect(commandRunner).toHaveBeenCalledTimes(1);
-    const firstCall = commandRunner.mock.calls[0];
-    const argv = firstCall[0];
-    expect(argv.slice(0, 2)).toEqual(['openclaw', 'agent']);
-    expect(argv).toContain('--agent');
-    expect(argv).toContain('ops');
+  });
+
+  it('post-run session reset failure is safe and does not fail fill output', async () => {
+    let resetCalls = 0;
+    const commandRunner = vi.fn(async (argv: string[], _options: unknown) => {
+      if (argv[0] === 'openclaw' && argv[1] === 'gateway' && argv[2] === 'call' && argv[3] === 'sessions.reset') {
+        resetCalls += 1;
+        if (resetCalls === 1) {
+          return {
+            stdout: '{"ok":true}',
+            stderr: '',
+            code: 0
+          };
+        }
+        return {
+          stdout: '',
+          stderr: 'reset failed',
+          code: 1
+        };
+      }
+      if (argv[0] === 'openclaw' && argv[1] === 'agent') {
+        return {
+          stdout: '{"values":{"summary":"new summary"}}',
+          stderr: '',
+          code: 0
+        };
+      }
+      return {
+        stdout: '',
+        stderr: `unsupported command: ${argv.join(' ')}`,
+        code: 1
+      };
+    });
+
+    const runner = createFillRunner(
+      config({
+        fill_provider: 'openclaw',
+        openclaw_fill_agent_id: 'ops'
+      }),
+      { commandRunner }
+    );
+    const response = await runner.run(context());
+
+    expect(response.values.summary).toBe('new summary');
+    expect(commandRunner).toHaveBeenCalledTimes(3);
+    expect(commandRunner.mock.calls[2][0].slice(0, 4)).toEqual(['openclaw', 'gateway', 'call', 'sessions.reset']);
   });
 
   it('parses command runner fenced json output', async () => {

package/src/fill-runner.ts

@@ -1,4 +1,4 @@
-import { runAndReadStdout, type CommandRunner } from './command-runner.js';
+import { runAndReadStdout, runCommand, type CommandRunner } from './command-runner.js';
 import type { FillResponse, FillRunContext, FillRunner, PlashboardConfig } from './types.js';
 
 export interface FillRunnerDeps {
@@ -142,6 +142,69 @@ function parseFillResponse(output: string, source: string): FillResponse {
   return extracted;
 }
 
+function extractGatewayCallErrorMessage(value: unknown): string | undefined {
+  const objectValue = asObject(value);
+  if (!objectValue) return undefined;
+
+  if (objectValue.ok === false) {
+    const rootMessage = typeof objectValue.message === 'string' ? objectValue.message.trim() : '';
+    if (rootMessage) return rootMessage;
+
+    const rootError = asObject(objectValue.error);
+    if (rootError) {
+      const nestedMessage = typeof rootError.message === 'string' ? rootError.message.trim() : '';
+      if (nestedMessage) return nestedMessage;
+    }
+    return 'gateway returned ok=false';
+  }
+
+  const errorValue = asObject(objectValue.error);
+  if (!errorValue) return undefined;
+  const message = typeof errorValue.message === 'string' ? errorValue.message.trim() : '';
+  return message || 'gateway returned error';
+}
+
+function fillSessionKey(agentId: string): string {
+  return `agent:${agentId}:main`;
+}
+
+async function resetFillSession(
+  commandRunner: CommandRunner | null,
+  agentId: string,
+  timeoutSeconds: number,
+  required: boolean
+): Promise<void> {
+  const sessionKey = fillSessionKey(agentId);
+  const params = JSON.stringify({
+    key: sessionKey,
+    reason: 'new'
+  });
+  const result = await runCommand(
+    commandRunner,
+    ['openclaw', 'gateway', 'call', 'sessions.reset', '--json', '--params', params],
+    {
+      timeoutMs: Math.max(10, timeoutSeconds) * 1000
+    },
+    'openclaw fill session reset'
+  );
+
+  const fail = (reason: string) => {
+    if (!required) return;
+    throw new Error(`openclaw fill session reset failed for ${sessionKey}: ${reason}`);
+  };
+
+  if (!result.ok) {
+    fail(result.error || result.stderr || result.stdout || `exit=${String(result.code)}`);
+    return;
+  }
+
+  const parsed = parseJsonCandidate(result.stdout);
+  const gatewayError = parsed !== undefined ? extractGatewayCallErrorMessage(parsed) : undefined;
+  if (gatewayError) {
+    fail(gatewayError);
+  }
+}
+
 class MockFillRunner implements FillRunner {
   async run(context: FillRunContext): Promise<FillResponse> {
     const values: Record<string, unknown> = {};
@@ -192,17 +255,25 @@ class OpenClawFillRunner implements FillRunner {
     const agentId = (this.config.openclaw_fill_agent_id || 'main').trim() || 'main';
     const timeoutSeconds = Math.max(10, Math.floor(this.config.session_timeout_seconds));
     const message = buildOpenClawMessage(context);
+    const argv = ['openclaw', 'agent', '--agent', agentId, '--message', message, '--json', '--timeout', String(timeoutSeconds)];
 
-    const output = await runAndReadStdout(
-      this.commandRunner,
-      ['openclaw', 'agent', '--agent', agentId, '--message', message, '--json', '--timeout', String(timeoutSeconds)],
-      {
-        timeoutMs: (timeoutSeconds + 30) * 1000
-      },
-      'openclaw fill'
-    );
+    // Always force a fresh fill session via official Gateway session API.
+    await resetFillSession(this.commandRunner, agentId, timeoutSeconds, true);
+
+    try {
+      const output = await runAndReadStdout(
+        this.commandRunner,
+        argv,
+        {
+          timeoutMs: (timeoutSeconds + 30) * 1000
+        },
+        'openclaw fill'
+      );
 
-    return parseFillResponse(output, 'openclaw fill');
+      return parseFillResponse(output, 'openclaw fill');
+    } finally {
+      await resetFillSession(this.commandRunner, agentId, timeoutSeconds, false);
+    }
   }
 }
 

package/src/plugin.ts

@@ -590,6 +590,7 @@ async function runSetup(
     auto_seed_template: selectedAutoSeed,
     display_profile: displayProfile
   };
+  delete nextPluginConfig.session_strategy;
 
   if (selectedCommand) {
     nextPluginConfig.fill_command = selectedCommand;