@jhytabest/plashboard 0.1.11 → 1.0.0

package/src/publisher.ts

@@ -1,6 +1,6 @@
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
 import { dirname, join } from 'node:path';
+import { runAndReadStdout, type CommandRunner } from './command-runner.js';
 import type { DisplayProfile, PlashboardConfig } from './types.js';
 
 interface PublishOptions {
@@ -9,49 +9,11 @@ interface PublishOptions {
   displayProfile: DisplayProfile;
 }
 
-function spawnPython(
-  pythonBin: string,
-  scriptPath: string,
-  args: string[],
-  profile: DisplayProfile,
-  tolerance: number
-): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(pythonBin, [scriptPath, ...args], {
-      env: {
-        ...process.env,
-        PLASH_TARGET_VIEWPORT_HEIGHT: String(profile.height_px),
-        PLASH_LAYOUT_SAFETY_MARGIN: String(profile.layout_safety_margin_px),
-        PLASH_LAYOUT_OVERFLOW_TOLERANCE: String(tolerance),
-        PLASH_FRAME_GUTTER_TOP: String(profile.safe_top_px),
-        PLASH_FRAME_GUTTER_BOTTOM: String(profile.safe_bottom_px)
-      }
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += String(chunk);
-    });
-
-    child.on('error', (error) => reject(error));
-
-    child.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(stderr.trim() || stdout.trim() || `writer script failed with code ${code}`));
-        return;
-      }
-      resolve(stdout.trim());
-    });
-  });
-}
-
 export class DashboardValidatorPublisher {
-  constructor(private readonly config: PlashboardConfig) {}
+  constructor(
+    private readonly config: PlashboardConfig,
+    private readonly commandRunner: CommandRunner | null
+  ) {}
 
   async validateOnly(payload: Record<string, unknown>, displayProfile: DisplayProfile): Promise<void> {
     await this.run(payload, {
@@ -75,22 +37,28 @@ export class DashboardValidatorPublisher {
     try {
       await writeFile(inputPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
 
-      const args = ['--input', inputPath];
+      const argv = [this.config.python_bin, this.config.writer_script_path, '--input', inputPath];
       if (options.validateOnly) {
-        args.push('--validate-only');
+        argv.push('--validate-only');
       } else {
-        args.push('--output', options.outputPath);
+        argv.push('--output', options.outputPath);
       }
 
-      const output = await spawnPython(
-        this.config.python_bin,
-        this.config.writer_script_path,
-        args,
-        options.displayProfile,
-        this.config.layout_overflow_tolerance_px
+      return await runAndReadStdout(
+        this.commandRunner,
+        argv,
+        {
+          timeoutMs: Math.max(15, this.config.session_timeout_seconds) * 1000,
+          env: {
+            PLASH_TARGET_VIEWPORT_HEIGHT: String(options.displayProfile.height_px),
+            PLASH_LAYOUT_SAFETY_MARGIN: String(options.displayProfile.layout_safety_margin_px),
+            PLASH_LAYOUT_OVERFLOW_TOLERANCE: String(this.config.layout_overflow_tolerance_px),
+            PLASH_FRAME_GUTTER_TOP: String(options.displayProfile.safe_top_px),
+            PLASH_FRAME_GUTTER_BOTTOM: String(options.displayProfile.safe_bottom_px)
+          }
+        },
+        'dashboard writer'
       );
-
-      return output;
     } finally {
       await rm(tempDir, { recursive: true, force: true });
     }

package/src/runtime.test.ts

@@ -1,9 +1,10 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { describe, expect, it } from 'vitest';
 import { PlashboardRuntime } from './runtime.js';
 import type { DashboardTemplate, PlashboardConfig } from './types.js';
+import type { CommandRunner } from './command-runner.js';
 
 function baseDashboard() {
   return {
@@ -63,6 +64,7 @@ async function setupRuntime(overrides: Partial<PlashboardConfig> = {}) {
     session_timeout_seconds: 30,
     auto_seed_template: false,
     fill_provider: 'mock',
+    allow_command_fill: false,
     fill_command: undefined,
     python_bin: 'python3',
     writer_script_path: join(process.cwd(), 'scripts', 'dashboard_write.py'),
@@ -80,11 +82,57 @@ async function setupRuntime(overrides: Partial<PlashboardConfig> = {}) {
     ...overrides
   };
 
-  const runtime = new PlashboardRuntime(config);
+  const runtime = new PlashboardRuntime(config, undefined, {
+    commandRunner: createTestCommandRunner()
+  });
   await runtime.init();
   return { runtime, root, config };
 }
 
+function createTestCommandRunner(): CommandRunner {
+  return async (argv: string[]) => {
+    if (argv[0] === 'openclaw' && argv[1] === 'agent') {
+      return {
+        stdout: '{"values":{"summary":"updated summary from openclaw"}}',
+        stderr: '',
+        code: 0
+      };
+    }
+
+    const inputIndex = argv.indexOf('--input');
+    if (argv[0] === 'python3' && inputIndex >= 0) {
+      const inputPath = argv[inputIndex + 1];
+      const outputIndex = argv.indexOf('--output');
+      const validateOnly = argv.includes('--validate-only');
+      const inputText = await readFile(inputPath, 'utf8');
+      const payload = JSON.parse(inputText) as Record<string, unknown>;
+
+      const normalized: Record<string, unknown> = {
+        ...payload,
+        version: typeof payload.version === 'string' ? payload.version : '3.0',
+        generated_at: new Date().toISOString()
+      };
+
+      if (!validateOnly && outputIndex >= 0) {
+        const outputPath = argv[outputIndex + 1];
+        await writeFile(outputPath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+      }
+
+      return {
+        stdout: 'ok',
+        stderr: '',
+        code: 0
+      };
+    }
+
+    return {
+      stdout: '',
+      stderr: `unsupported test command: ${argv.join(' ')}`,
+      code: 1
+    };
+  };
+}
+
 describe('PlashboardRuntime', () => {
   it('creates template and runs pipeline with publish', async () => {
     const { runtime, root, config } = await setupRuntime();
@@ -175,6 +223,8 @@ describe('PlashboardRuntime', () => {
       const status = await runtime.status();
       expect(status.ok).toBe(true);
       expect(status.data?.active_template_id).toBe('starter');
+      expect(status.data?.capabilities.runtime_command_runner_available).toBe(true);
+      expect(status.data?.capabilities.command_fill_allowed).toBe(false);
     } finally {
       await rm(root, { recursive: true, force: true });
     }

package/src/runtime.ts

@@ -18,6 +18,7 @@ import { collectCurrentValues, mergeTemplateValues, validateFieldPointers } from
 import { validateFillShape, validateTemplateShape } from './schema-validation.js';
 import { DashboardValidatorPublisher } from './publisher.js';
 import { createFillRunner, type FillRunnerDeps } from './fill-runner.js';
+import type { CommandRunner } from './command-runner.js';
 
 interface Logger {
   info(message: string, ...args: unknown[]): void;
@@ -76,6 +77,7 @@ export class PlashboardRuntime {
   private readonly runStore: RunStore;
   private readonly publisher: DashboardValidatorPublisher;
   private readonly fillRunner: FillRunner;
+  private readonly runtimeCommandRunnerAvailable: boolean;
 
   private schedulerTimer: NodeJS.Timeout | null = null;
   private tickInProgress = false;
@@ -91,7 +93,9 @@ export class PlashboardRuntime {
     this.stateStore = new StateStore(this.paths);
     this.templateStore = new TemplateStore(this.paths);
     this.runStore = new RunStore(this.paths);
-    this.publisher = new DashboardValidatorPublisher(config);
+    const commandRunner: CommandRunner | null = fillRunnerDeps.commandRunner ?? null;
+    this.runtimeCommandRunnerAvailable = Boolean(commandRunner);
+    this.publisher = new DashboardValidatorPublisher(config, commandRunner);
     this.fillRunner = createFillRunner(config, fillRunnerDeps);
   }
 
@@ -462,6 +466,10 @@ export class PlashboardRuntime {
         template_count: templates.length,
         enabled_template_count: templates.filter((entry) => entry.enabled).length,
         running_template_ids: [...this.runningTemplates],
+        capabilities: {
+          runtime_command_runner_available: this.runtimeCommandRunnerAvailable,
+          command_fill_allowed: this.config.allow_command_fill
+        },
         state
       }
     };

package/src/types.ts

@@ -25,6 +25,7 @@ export interface PlashboardConfig {
   session_timeout_seconds: number;
   auto_seed_template: boolean;
   fill_provider: 'command' | 'mock' | 'openclaw';
+  allow_command_fill: boolean;
   fill_command?: string;
   openclaw_fill_agent_id?: string;
   python_bin: string;
@@ -137,5 +138,9 @@ export interface RuntimeStatus {
   template_count: number;
   enabled_template_count: number;
   running_template_ids: string[];
+  capabilities: {
+    runtime_command_runner_available: boolean;
+    command_fill_allowed: boolean;
+  };
   state: PlashboardState;
 }