@jhytabest/plashboard 1.0.1 → 1.0.2

package/README.md

@@ -25,7 +25,6 @@ No manual config is required for first use. Defaults are safe:
 - `fill_provider=openclaw`
 - `allow_command_fill=false`
 - `openclaw_fill_agent_id=main`
-- `session_strategy=persistent`
 - automatic init on service start
 - automatic starter template seed when template store is empty
 
@@ -59,7 +58,6 @@ Add to `openclaw.json`:
           "fill_provider": "openclaw",
           "allow_command_fill": false,
           "openclaw_fill_agent_id": "main",
-          "session_strategy": "persistent",
           "display_profile": {
             "width_px": 1920,
             "height_px": 1080,
@@ -79,32 +77,11 @@ 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.
 
-`session_strategy` controls OpenClaw session reuse for fills:
-- `persistent` (default): reuses the agent's normal long-lived session behavior.
-- `ephemeral`: each fill run gets a unique `--session-id`; after the run, plugin performs best-effort cleanup via official CLI API: `openclaw sessions delete --agent <id> --session-id <id>`.
+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.
 
-Tradeoffs:
-- `persistent` keeps conversational memory/context between runs.
-- `ephemeral` isolates runs and avoids long-lived context drift, but loses cross-run memory and adds one cleanup CLI call per run.
-
-Example ephemeral config:
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "plashboard": {
-        "enabled": true,
-        "config": {
-          "fill_provider": "openclaw",
-          "openclaw_fill_agent_id": "plashboard-fill",
-          "session_strategy": "ephemeral"
-        }
-      }
-    }
-  }
-}
-```
+This keeps fill runs stateless without editing OpenClaw session files directly.
 
 For production stability, use a dedicated fill agent instead of `main`:
 

package/openclaw.plugin.json

@@ -20,7 +20,6 @@
       "allow_command_fill": { "type": "boolean", "default": false },
       "fill_command": { "type": "string" },
       "openclaw_fill_agent_id": { "type": "string", "default": "main" },
-      "session_strategy": { "type": "string", "enum": ["persistent", "ephemeral"], "default": "persistent" },
       "python_bin": { "type": "string", "default": "python3" },
       "writer_script_path": { "type": "string" },
       "dashboard_output_path": { "type": "string" },

package/package.json

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

package/src/config.ts

@@ -38,10 +38,6 @@ function asObject(value: unknown): Record<string, unknown> {
     : {};
 }
 
-function asSessionStrategy(value: unknown): PlashboardConfig['session_strategy'] {
-  return value === 'ephemeral' ? 'ephemeral' : 'persistent';
-}
-
 function resolveDisplayProfile(raw: unknown): DisplayProfile {
   const data = asObject(raw);
   return {
@@ -84,7 +80,6 @@ export function resolveConfig(api: unknown): PlashboardConfig {
     allow_command_fill: asBoolean(raw.allow_command_fill, false),
     fill_command: typeof raw.fill_command === 'string' ? raw.fill_command : undefined,
     openclaw_fill_agent_id: asString(raw.openclaw_fill_agent_id, 'main'),
-    session_strategy: asSessionStrategy(raw.session_strategy),
     python_bin: asString(raw.python_bin, 'python3'),
     writer_script_path: asString(raw.writer_script_path, DEFAULT_WRITER_PATH),
     dashboard_output_path: outputPath,

package/src/fill-runner.test.ts

@@ -42,7 +42,6 @@ function config(overrides: Partial<PlashboardConfig>): PlashboardConfig {
     allow_command_fill: false,
     fill_command: undefined,
     openclaw_fill_agent_id: 'main',
-    session_strategy: 'persistent',
     python_bin: 'python3',
     writer_script_path: '/tmp/writer.py',
     dashboard_output_path: '/tmp/dashboard.json',
@@ -69,20 +68,38 @@ function context(): FillRunContext {
 }
 
 describe('createFillRunner', () => {
-  it('persistent mode keeps standard openclaw agent session behavior', 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' }),
@@ -91,31 +108,33 @@ describe('createFillRunner', () => {
     const response = await runner.run(context());
 
     expect(response.values.summary).toBe('new summary');
-    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');
-    expect(argv).not.toContain('--session-id');
+    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('ephemeral mode uses unique session ids and official cleanup command', async () => {
-    const calls: string[][] = [];
+  it('fails fill when pre-run session reset fails', async () => {
     const commandRunner = vi.fn(async (argv: string[], _options: unknown) => {
-      calls.push(argv);
-      if (argv[0] === 'openclaw' && argv[1] === 'agent') {
+      if (argv[0] === 'openclaw' && argv[1] === 'gateway' && argv[2] === 'call' && argv[3] === 'sessions.reset') {
         return {
-          stdout: '{"values":{"summary":"new summary"}}',
-          stderr: '',
-          code: 0
-        };
-      }
-      if (argv[0] === 'openclaw' && argv[1] === 'sessions' && argv[2] === 'delete') {
-        return {
-          stdout: '{"ok":true}',
-          stderr: '',
-          code: 0
+          stdout: '',
+          stderr: 'reset failed',
+          code: 1
         };
       }
       return {
@@ -128,43 +147,33 @@ describe('createFillRunner', () => {
     const runner = createFillRunner(
       config({
         fill_provider: 'openclaw',
-        openclaw_fill_agent_id: 'ops',
-        session_strategy: 'ephemeral'
+        openclaw_fill_agent_id: 'ops'
       }),
       { commandRunner }
     );
 
-    await runner.run(context());
-    await runner.run(context());
-
-    const agentCalls = calls.filter((argv) => argv[0] === 'openclaw' && argv[1] === 'agent');
-    const cleanupCalls = calls.filter((argv) => argv[0] === 'openclaw' && argv[1] === 'sessions' && argv[2] === 'delete');
-
-    expect(agentCalls).toHaveLength(2);
-    expect(cleanupCalls).toHaveLength(2);
-
-    const firstSessionFlagIndex = agentCalls[0].indexOf('--session-id');
-    const secondSessionFlagIndex = agentCalls[1].indexOf('--session-id');
-    expect(firstSessionFlagIndex).toBeGreaterThan(-1);
-    expect(secondSessionFlagIndex).toBeGreaterThan(-1);
-    const firstSessionId = agentCalls[0][firstSessionFlagIndex + 1];
-    const secondSessionId = agentCalls[1][secondSessionFlagIndex + 1];
-    expect(firstSessionId).toBeTruthy();
-    expect(secondSessionId).toBeTruthy();
-    expect(firstSessionId).not.toBe(secondSessionId);
-
-    for (const [index, cleanupCall] of cleanupCalls.entries()) {
-      expect(cleanupCall.slice(0, 3)).toEqual(['openclaw', 'sessions', 'delete']);
-      expect(cleanupCall).toContain('--agent');
-      expect(cleanupCall).toContain('ops');
-      const cleanupSessionFlagIndex = cleanupCall.indexOf('--session-id');
-      expect(cleanupSessionFlagIndex).toBeGreaterThan(-1);
-      expect(cleanupCall[cleanupSessionFlagIndex + 1]).toBe(index === 0 ? firstSessionId : secondSessionId);
-    }
+    await expect(runner.run(context())).rejects.toThrow(/session reset failed/i);
+    expect(commandRunner).toHaveBeenCalledTimes(1);
   });
 
-  it('ephemeral cleanup failure is safe and does not fail fill output', async () => {
+  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"}}',
@@ -172,13 +181,6 @@ describe('createFillRunner', () => {
           code: 0
         };
       }
-      if (argv[0] === 'openclaw' && argv[1] === 'sessions' && argv[2] === 'delete') {
-        return {
-          stdout: '',
-          stderr: 'session cleanup failed',
-          code: 1
-        };
-      }
       return {
         stdout: '',
         stderr: `unsupported command: ${argv.join(' ')}`,
@@ -189,16 +191,15 @@ describe('createFillRunner', () => {
     const runner = createFillRunner(
       config({
         fill_provider: 'openclaw',
-        openclaw_fill_agent_id: 'ops',
-        session_strategy: 'ephemeral'
+        openclaw_fill_agent_id: 'ops'
       }),
       { commandRunner }
     );
     const response = await runner.run(context());
 
     expect(response.values.summary).toBe('new summary');
-    expect(commandRunner).toHaveBeenCalledTimes(2);
-    expect(commandRunner.mock.calls[1][0].slice(0, 3)).toEqual(['openclaw', 'sessions', 'delete']);
+    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

@@ -5,8 +5,6 @@ export interface FillRunnerDeps {
   commandRunner?: CommandRunner | null;
 }
 
-let ephemeralSessionCounter = 0;
-
 function buildPromptPayload(context: FillRunContext): Record<string, unknown> {
   return {
     instructions: {
@@ -144,23 +142,67 @@ function parseFillResponse(output: string, source: string): FillResponse {
   return extracted;
 }
 
-function sanitizeSessionToken(input: string): string {
-  return input.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24) || 'x';
+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 nextEphemeralSessionCounter(): number {
-  ephemeralSessionCounter += 1;
-  return ephemeralSessionCounter;
+function fillSessionKey(agentId: string): string {
+  return `agent:${agentId}:main`;
 }
 
-function buildEphemeralSessionId(agentId: string, context: FillRunContext): string {
-  const templateId = sanitizeSessionToken(context.template.id || 'template');
-  const agent = sanitizeSessionToken(agentId || 'agent');
-  const attempt = Math.max(1, Math.floor(context.attempt || 1));
-  const now = Date.now().toString(36);
-  const pid = process.pid.toString(36);
-  const seq = nextEphemeralSessionCounter().toString(36);
-  return `plash-${agent}-${templateId}-a${attempt}-${pid}-${now}-${seq}`;
+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 {
@@ -213,12 +255,10 @@ 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 ephemeral = this.config.session_strategy === 'ephemeral';
-    const sessionId = ephemeral ? buildEphemeralSessionId(agentId, context) : undefined;
     const argv = ['openclaw', 'agent', '--agent', agentId, '--message', message, '--json', '--timeout', String(timeoutSeconds)];
-    if (sessionId) {
-      argv.push('--session-id', sessionId);
-    }
+
+    // Always force a fresh fill session via official Gateway session API.
+    await resetFillSession(this.commandRunner, agentId, timeoutSeconds, true);
 
     try {
       const output = await runAndReadStdout(
@@ -232,17 +272,7 @@ class OpenClawFillRunner implements FillRunner {
 
       return parseFillResponse(output, 'openclaw fill');
     } finally {
-      if (ephemeral && sessionId) {
-        // Best-effort cleanup through official CLI API; never mutate session files directly.
-        await runCommand(
-          this.commandRunner,
-          ['openclaw', 'sessions', 'delete', '--agent', agentId, '--session-id', sessionId, '--json'],
-          {
-            timeoutMs: Math.max(5, timeoutSeconds) * 1000
-          },
-          'openclaw ephemeral session cleanup'
-        );
-      }
+      await resetFillSession(this.commandRunner, agentId, timeoutSeconds, false);
     }
   }
 }

package/src/plugin.ts

@@ -80,7 +80,6 @@ type SetupParams = {
   allow_command_fill?: boolean;
   fill_command?: string;
   openclaw_fill_agent_id?: string;
-  session_strategy?: 'persistent' | 'ephemeral';
   auto_seed_template?: boolean;
   data_dir?: string;
   scheduler_tick_seconds?: number;
@@ -515,10 +514,6 @@ async function runSetup(
     || asString(resolvedConfig.openclaw_fill_agent_id)
     || 'main'
   ).trim();
-  const rawSessionStrategy = asString(params.session_strategy)
-    || asString(currentPluginConfig.session_strategy)
-    || asString(resolvedConfig.session_strategy);
-  const selectedSessionStrategy = rawSessionStrategy === 'ephemeral' ? 'ephemeral' : 'persistent';
 
   if (selectedProvider === 'command' && !selectedCommand) {
     return {
@@ -592,10 +587,10 @@ async function runSetup(
     ),
     fill_provider: selectedProvider,
     allow_command_fill: selectedAllowCommandFill,
-    session_strategy: selectedSessionStrategy,
     auto_seed_template: selectedAutoSeed,
     display_profile: displayProfile
   };
+  delete nextPluginConfig.session_strategy;
 
   if (selectedCommand) {
     nextPluginConfig.fill_command = selectedCommand;
@@ -636,7 +631,6 @@ async function runSetup(
       allow_command_fill: selectedAllowCommandFill,
       fill_command: selectedProvider === 'command' ? selectedCommand : undefined,
       openclaw_fill_agent_id: selectedProvider === 'openclaw' ? selectedAgentId : undefined,
-      session_strategy: selectedSessionStrategy,
       auto_seed_template: selectedAutoSeed,
       data_dir: nextPluginConfig.data_dir,
       scheduler_tick_seconds: nextPluginConfig.scheduler_tick_seconds,
@@ -1071,7 +1065,6 @@ export function registerPlashboardPlugin(api: UnknownApi): void {
         allow_command_fill: { type: 'boolean' },
         fill_command: { type: 'string' },
         openclaw_fill_agent_id: { type: 'string' },
-        session_strategy: { type: 'string', enum: ['persistent', 'ephemeral'] },
         auto_seed_template: { type: 'boolean' },
         data_dir: { type: 'string' },
         scheduler_tick_seconds: { type: 'number' },

package/src/runtime.test.ts

@@ -66,7 +66,6 @@ async function setupRuntime(overrides: Partial<PlashboardConfig> = {}) {
     fill_provider: 'mock',
     allow_command_fill: false,
     fill_command: undefined,
-    session_strategy: 'persistent',
     python_bin: 'python3',
     writer_script_path: join(process.cwd(), 'scripts', 'dashboard_write.py'),
     dashboard_output_path: join(root, 'dashboard.json'),

package/src/types.ts

@@ -15,8 +15,6 @@ export interface ModelDefaults {
   max_tokens?: number;
 }
 
-export type SessionStrategy = 'persistent' | 'ephemeral';
-
 export interface PlashboardConfig {
   data_dir: string;
   timezone: string;
@@ -30,7 +28,6 @@ export interface PlashboardConfig {
   allow_command_fill: boolean;
   fill_command?: string;
   openclaw_fill_agent_id?: string;
-  session_strategy: SessionStrategy;
   python_bin: string;
   writer_script_path: string;
   dashboard_output_path: string;