yaml-flow 8.5.3 → 8.6.2

package/examples/board/server/board-worker/task-executor.js

@@ -283,6 +283,60 @@ async function runSourceFetchSubcommand(argv) {
 
 }
 
+async function executeLogicalSourceFetchRequest(request) {
+  const sourceDef = request?.source_def;
+  const callback = request?.callback;
+  const outputRefStr = typeof request?.output?.ref === 'string' ? request.output.ref : undefined;
+  const diagnosticsRefStr = typeof request?.diagnostics?.ref === 'string' ? request.diagnostics.ref : undefined;
+  const extra = request?.extra && typeof request.extra === 'object' && !Array.isArray(request.extra) ? request.extra : {};
+
+  if (!sourceDef || typeof sourceDef !== 'object' || Array.isArray(sourceDef)) {
+    throw new Error('executeBoardWorkerRequest requires source_def');
+  }
+  if (!outputRefStr) {
+    throw new Error('executeBoardWorkerRequest requires output.ref');
+  }
+
+  const outRef = parseRef(outputRefStr);
+  const errRef = diagnosticsRefStr ? parseRef(diagnosticsRefStr) : undefined;
+  const outStorage = blobStorageForRef(outRef);
+  const errStorage = errRef ? blobStorageForRef(errRef) : undefined;
+
+  const reportHostedFailure = (msg) => {
+    if (errStorage && errRef) { try { errStorage.write(errRef.value, msg); } catch {} }
+    console.error(`${LOG_PREFIX} ${msg}`);
+    if (callback) { try { reportFailed(callback, msg); } catch {} }
+  };
+
+  let flowResult;
+  try {
+    const resolved = await resolveAndExecuteSourceFlow(sourceDef, extra, { outRef, errRef });
+    flowResult = resolved.flowResult;
+  } catch (err) {
+    const detail = (err && (err.stderr || err.stdout)) ? `\n${err.stderr || err.stdout}`.trimEnd() : '';
+    reportHostedFailure(`source invocation failed: ${String(err && err.message || err)}${detail}`);
+    return;
+  }
+
+  if (!flowResult?.wroteOutputDirectly) {
+    try {
+      outStorage.write(outRef.value, JSON.stringify(flowResult?.resultValue, null, 2));
+    } catch (err) {
+      const msg = `Cannot write output: ${String(err && err.message || err)}`;
+      reportHostedFailure(msg);
+      throw new Error(msg);
+    }
+  }
+
+  if (callback) {
+    try {
+      reportComplete(callback, outRef);
+    } catch (err) {
+      throw new Error(`reportComplete failed: ${String(err && err.message || err)}`);
+    }
+  }
+}
+
 async function probeSourcePreflightSubcommand(argv) {
   const extraIdx = argv.indexOf('--extra');
   const extraB64 = extraIdx !== -1 ? argv[extraIdx + 1] : undefined;
@@ -293,24 +347,27 @@ async function probeSourcePreflightSubcommand(argv) {
     catch { /* ignore malformed extra */ }
   }
 
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const result = await probeSourcePreflightRequest(Buffer.concat(chunks).toString('utf-8').trim(), extra);
+  console.log(JSON.stringify(result));
+}
+
+async function probeSourcePreflightRequest(raw, extra = {}) {
+
   const startedAt = Date.now();
   try {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    const raw = Buffer.concat(chunks).toString('utf-8').trim();
     if (!raw) {
-      console.log(JSON.stringify({ ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: 'Missing probe input JSON on stdin' }));
-      return;
+      return { ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: 'Missing probe input JSON on stdin' };
     }
 
     let sourceDef;
     try {
       sourceDef = JSON.parse(raw);
     } catch (err) {
-      console.log(JSON.stringify({ ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `Invalid probe JSON: ${String(err && err.message || err)}` }));
-      return;
+      return { ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `Invalid probe JSON: ${String(err && err.message || err)}` };
     }
 
     const projections = sourceDef?._projections;
@@ -320,18 +377,16 @@ async function probeSourcePreflightSubcommand(argv) {
       : undefined;
 
     const { flowResult } = await resolveAndExecuteSourceFlow(sourceDef, extra);
-    console.log(JSON.stringify({
+    return {
       ok: true,
       reachable: true,
       latencyMs: Date.now() - startedAt,
       ...(mockProjectionWarning ? { note: mockProjectionWarning } : {}),
       ...(!mockProjectionWarning ? { resultValue: flowResult?.resultValue } : {}),
-    }));
-    return;
+    };
   } catch (err) {
     const detail = (err && (err.stderr || err.stdout)) ? `\n${err.stderr || err.stdout}`.trimEnd() : '';
-    console.log(JSON.stringify({ ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `source invocation failed: ${String(err && err.message || err)}${detail}` }));
-    return;
+    return { ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `source invocation failed: ${String(err && err.message || err)}${detail}` };
   }
 }
 
@@ -364,26 +419,29 @@ async function runSourcePreflightSubcommand(argv) {
     catch { /* ignore malformed extra */ }
   }
 
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const result = await runSourcePreflightRequest(Buffer.concat(chunks).toString('utf-8').trim(), extra);
+  console.log(JSON.stringify(result));
+}
+
+async function runSourcePreflightRequest(raw, extra = {}) {
+
   const startedAt = Date.now();
   let bindTo;
   let kind;
   try {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    const raw = Buffer.concat(chunks).toString('utf-8').trim();
     if (!raw) {
-      console.log(JSON.stringify({ ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: 'Missing run-source-preflight input JSON on stdin' }));
-      return;
+      return { ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: 'Missing run-source-preflight input JSON on stdin' };
     }
 
     let sourceDef;
     try {
       sourceDef = JSON.parse(raw);
     } catch (err) {
-      console.log(JSON.stringify({ ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `Invalid run-source-preflight JSON: ${String(err && err.message || err)}` }));
-      return;
+      return { ok: false, reachable: false, latencyMs: Date.now() - startedAt, error: `Invalid run-source-preflight JSON: ${String(err && err.message || err)}` };
     }
 
     bindTo = typeof sourceDef?.bindTo === 'string' ? sourceDef.bindTo : undefined;
@@ -391,7 +449,7 @@ async function runSourcePreflightSubcommand(argv) {
 
     const resolved = await resolveAndExecuteSourceFlow(sourceDef, extra);
     kind = resolved.kind;
-    console.log(JSON.stringify({
+    return {
       ok: true,
       reachable: true,
       latencyMs: Date.now() - startedAt,
@@ -399,19 +457,17 @@ async function runSourcePreflightSubcommand(argv) {
       ...(kind ? { kind } : {}),
       resultValue: resolved.flowResult?.resultValue,
       note: 'Actual fetch preflight passed',
-    }));
-    return;
+    };
   } catch (err) {
     const detail = (err && (err.stderr || err.stdout)) ? `\n${err.stderr || err.stdout}`.trimEnd() : '';
-    console.log(JSON.stringify({
+    return {
       ok: false,
       reachable: false,
       latencyMs: Date.now() - startedAt,
       ...(bindTo ? { bindTo } : {}),
       ...(kind ? { kind } : {}),
       error: `${String(err && err.message || err)}${detail}`,
-    }));
-    return;
+    };
   }
 }
 
@@ -455,26 +511,16 @@ function matchesValidateRule(sourceDef, rule) {
 // ---------------------------------------------------------------------------
 // validate-source-def — registry-driven validation of a source definition
 // ---------------------------------------------------------------------------
-function validateSourceDefSubcommand() {
-  let rawInput = '';
-  try {
-    rawInput = fs.readFileSync(0, 'utf-8').trim();
-  } catch (err) {
-    console.log(JSON.stringify({ ok: false, errors: [`Cannot read stdin: ${err && err.message || err}`] }));
-    process.exit(1);
-  }
-
+function validateSourceDefPayload(rawInput) {
   if (!rawInput) {
-    console.error(`${LOG_PREFIX} Usage: validate-source-def < source.json`);
-    process.exit(1);
+    return { ok: false, errors: ['Missing source JSON on stdin'] };
   }
 
   let sourceDef;
   try {
     sourceDef = JSON.parse(rawInput);
   } catch (err) {
-    console.log(JSON.stringify({ ok: false, errors: [`Cannot parse source JSON from stdin: ${err && err.message || err}`] }));
-    process.exit(1);
+    return { ok: false, errors: [`Cannot parse source JSON from stdin: ${err && err.message || err}`] };
   }
 
   const errors = [];
@@ -500,12 +546,23 @@ function validateSourceDefSubcommand() {
     }
   }
 
-  const result = { ok: errors.length === 0, errors };
+  return { ok: errors.length === 0, errors };
+}
+
+function validateSourceDefSubcommand() {
+  let rawInput = '';
+  try {
+    rawInput = fs.readFileSync(0, 'utf-8').trim();
+  } catch (err) {
+    console.log(JSON.stringify({ ok: false, errors: [`Cannot read stdin: ${err && err.message || err}`] }));
+    process.exit(1);
+  }
+  const result = validateSourceDefPayload(rawInput);
   console.log(JSON.stringify(result));
-  process.exit(errors.length === 0 ? 0 : 1);
+  process.exit(result.ok ? 0 : 1);
 }
 
-function describeCapabilities() {
+function describeCapabilitiesPayload() {
   const registry = loadSourceDefFlowsConfig();
   const sourceKinds = Object.fromEntries(
     Object.entries(registry?.kinds || {}).map(([kind, spec]) => [
@@ -516,7 +573,7 @@ function describeCapabilities() {
       },
     ]),
   );
-  const payload = {
+  return {
     version: registry?.version || '1.0',
     executor: registry?.executor || EXECUTOR_NAME,
     subcommands: Array.isArray(registry?.subcommands)
@@ -525,7 +582,63 @@ function describeCapabilities() {
     sourceKinds,
     ...(registry?.extraSchema ? { extraSchema: registry.extraSchema } : {}),
   };
-  console.log(JSON.stringify(payload, null, 2));
+}
+
+function describeCapabilities() {
+  console.log(JSON.stringify(describeCapabilitiesPayload(), null, 2));
+}
+
+function buildTaskExecutorArgvFromRequest(request) {
+  const subcommand = typeof request?.subcommand === 'string' ? request.subcommand.trim() : '';
+  if (!subcommand) {
+    throw new Error('executeTaskExecutorRequest requires subcommand');
+  }
+
+  const argv = [];
+  if (typeof request?.inRef === 'string' && request.inRef.trim()) argv.push('--in-ref', request.inRef.trim());
+  if (typeof request?.outRef === 'string' && request.outRef.trim()) argv.push('--out-ref', request.outRef.trim());
+  if (typeof request?.errRef === 'string' && request.errRef.trim()) argv.push('--err-ref', request.errRef.trim());
+  if (request?.extra && typeof request.extra === 'object' && !Array.isArray(request.extra)) {
+    argv.push('--extra', Buffer.from(JSON.stringify(request.extra)).toString('base64'));
+  }
+  return { subcommand, argv };
+}
+
+export async function executeBoardWorkerRequest(request) {
+  if (request?.source_def) {
+    await executeLogicalSourceFetchRequest(request);
+    return { ok: true };
+  }
+  const { subcommand, argv } = buildTaskExecutorArgvFromRequest(request);
+  const inlineInput = typeof request?.input === 'string'
+    ? request.input
+    : request?.input !== undefined
+      ? JSON.stringify(request.input)
+      : '';
+  const inlineExtra = request?.extra && typeof request.extra === 'object' && !Array.isArray(request.extra) ? request.extra : {};
+
+  if (subcommand === 'run-source-fetch') {
+    await runSourceFetchSubcommand(argv);
+    return { ok: true };
+  }
+  if (subcommand === 'probe-source-preflight') {
+    return await probeSourcePreflightRequest(inlineInput, inlineExtra);
+  }
+  if (subcommand === 'run-source-preflight') {
+    return await runSourcePreflightRequest(inlineInput, inlineExtra);
+  }
+  if (subcommand === 'describe' || subcommand === 'describe-capabilities') {
+    return describeCapabilitiesPayload();
+  }
+  if (subcommand === 'validate-source-def') {
+    return validateSourceDefPayload(inlineInput);
+  }
+
+  throw new Error(`Unknown subcommand: ${subcommand}`);
+}
+
+export async function executeTaskExecutorRequest(request) {
+  return executeBoardWorkerRequest(request);
 }
 
 async function main() {
@@ -555,7 +668,9 @@ async function main() {
   process.exit(0);
 }
 
-main().catch(err => {
-  console.error(`${LOG_PREFIX} fatal: ${err && err.message || err}`);
-  process.exit(1);
-});
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch(err => {
+    console.error(`${LOG_PREFIX} fatal: ${err && err.message || err}`);
+    process.exit(1);
+  });
+}

package/examples/board/server/chat-flow/copilot-chat/assistant.js

@@ -5,23 +5,24 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { readJsonStdin } from './shared.js';
 
 const HANDLER_DIR = path.dirname(fileURLToPath(import.meta.url));
 const WRAPPER_BAT = path.join(HANDLER_DIR, 'copilot_wrapper.bat');
+const DBG_LOG = path.join(HANDLER_DIR, 'assistant-debug.log');
+const DBG_ENABLED = String(process.env.YAML_FLOW_CHAT_DEBUG || '').toLowerCase() === 'true';
 
-function readJsonStdin() {
-  if (process.stdin.isTTY) return {};
-  try {
-    const raw = fs.readFileSync(0, 'utf-8').trim();
-    if (!raw) return {};
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === 'object' ? parsed : {};
-  } catch {
-    return {};
-  }
-}
+const dbg = DBG_ENABLED
+  ? (msg) => {
+      try {
+        fs.appendFileSync(DBG_LOG, `[assistant.DBG ${new Date().toISOString()} pid=${process.pid}] ${msg}\n`);
+      } catch {}
+    }
+  : () => {};
 
+dbg('startup: reading JSON stdin');
 const extra = readJsonStdin();
+dbg(`startup: stdin parsed (keys=${Object.keys(extra || {}).join(',')})`);
 const {
   cardId = '',
   boardSetupRoot = '',
@@ -74,8 +75,10 @@ function runCopilot(prompt, workingDir) {
   const ts = Date.now();
   const promptFile = path.join(os.tmpdir(), `asst-prompt-${ts}.txt`);
   const outFile = path.join(os.tmpdir(), `asst-out-${ts}.txt`);
+  dbg(`runCopilot: writing prompt (${prompt.length} chars) to ${promptFile}`);
   fs.writeFileSync(promptFile, prompt, 'utf-8');
   try {
+    dbg(`runCopilot: spawning wrapper ${WRAPPER_BAT} (timeout=${chatCopilotTimeoutMs}ms, cwd=${workingDir || process.cwd()})`);
     execFileSync('cmd.exe', [
       '/d', '/c', WRAPPER_BAT,
       outFile,
@@ -91,7 +94,11 @@ function runCopilot(prompt, workingDir) {
       timeout: chatCopilotTimeoutMs,
       windowsHide: true,
     });
-    return fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf-8').trim() : '';
+    const hasOut = fs.existsSync(outFile);
+    const out = hasOut ? fs.readFileSync(outFile, 'utf-8').trim() : '';
+    dbg(`runCopilot: wrapper returned (outFileExists=${hasOut}, replyLen=${out.length})`);
+    dbg(`runCopilot: reply snippet: ${JSON.stringify(out.slice(0, 400))}`);
+    return out;
   } finally {
     try { fs.unlinkSync(promptFile); } catch {}
     try { fs.unlinkSync(outFile); } catch {}
@@ -100,15 +107,21 @@ function runCopilot(prompt, workingDir) {
 
 const historyDump = JSON.stringify(chatMessages, null, 2);
 const workingDir = boardSetupRoot;
+dbg(`main: cardId=${cardId} turnId=${turnId} userTextLen=${String(userText).length} history=${chatMessages.length} workingDir=${workingDir}`);
 const prompt = buildPrompt(cardId, historyDump, userText.trim(), String(turnId || '').trim());
+dbg(`main: prompt built (${prompt.length} chars)`);
 
 try {
   const replyText = runCopilot(prompt, workingDir).trim();
+  dbg(`main: runCopilot returned replyLen=${replyText.length}`);
   if (!replyText) {
+    dbg('main: empty reply, throwing');
     throw new Error('Copilot returned an empty response');
   }
   process.stdout.write(JSON.stringify({ replyText }));
+  dbg('main: reply written to stdout, exiting 0');
 } catch (err) {
+  dbg(`main: error caught: ${err?.message ?? String(err)}`);
   process.stderr.write((err?.message ?? String(err)) + '\n');
   process.exit(1);
 }

package/examples/board/server/chat-flow/copilot-chat/probe.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import { readJsonStdin } from './shared.js';
+
+const input = readJsonStdin();
+const userText = typeof input.userText === 'string' ? input.userText : '';
+process.stdout.write(JSON.stringify({ replyText: `Echo: ${userText}` }));

package/examples/board/server/chat-flow/copilot-chat/shared.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import * as fs from 'node:fs';
+import * as http from 'node:http';
+
+export function readJsonStdin() {
+  if (process.stdin.isTTY) return {};
+  try {
+    const raw = fs.readFileSync(0, 'utf-8').trim();
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function httpJson(method, targetUrl, payload) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(targetUrl);
+    const data = Buffer.from(JSON.stringify(payload), 'utf-8');
+    const req = http.request({
+      hostname: target.hostname,
+      port: target.port,
+      path: target.pathname + target.search,
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': data.length,
+      },
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      res.on('end', () => {
+        const bodyText = Buffer.concat(chunks).toString('utf-8');
+        let body = null;
+        try { body = bodyText ? JSON.parse(bodyText) : null; } catch { body = bodyText; }
+        resolve({ status: res.statusCode || 0, body });
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+export async function invokeControlplaneTool({ serverUrl, boardId, tool, args }) {
+  const trimmedServerUrl = String(serverUrl || '').trim().replace(/\/+$/, '');
+  const trimmedBoardId = String(boardId || '').trim();
+  const trimmedTool = String(tool || '').trim();
+  if (!trimmedServerUrl) throw new Error('serverUrl is required');
+  if (!trimmedBoardId) throw new Error('boardId is required');
+  if (!trimmedTool) throw new Error('tool is required');
+
+  const result = await httpJson('POST', `${trimmedServerUrl}/api/boards/${encodeURIComponent(trimmedBoardId)}/mcp-controlplane`, {
+    tool: trimmedTool,
+    args,
+  });
+
+  if (result.status !== 200) {
+    const message = result.body && typeof result.body === 'object' && typeof result.body.error === 'string'
+      ? result.body.error
+      : `controlplane tool failed with status ${result.status}`;
+    throw new Error(message);
+  }
+
+  return result.body;
+}
+
+async function main() {
+  const input = readJsonStdin();
+  const action = typeof input.action === 'string' ? input.action.trim() : '';
+  if (action !== 'set-chat-processing-done') {
+    throw new Error('shared.js requires action="set-chat-processing-done"');
+  }
+  const serverUrl = typeof input.serverUrl === 'string' ? input.serverUrl : '';
+  const boardId = typeof input.boardId === 'string' ? input.boardId : '';
+  const cardId = typeof input.cardId === 'string' ? input.cardId : '';
+  if (!cardId) throw new Error('cardId is required');
+
+  const result = await invokeControlplaneTool({
+    serverUrl,
+    boardId,
+    tool: 'setstate.chat-processing-done',
+    args: { board_id: boardId, card_id: cardId },
+  });
+
+  process.stdout.write(JSON.stringify(result));
+}
+
+const isMain = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url));
+if (isMain) {
+  main().catch((err) => {
+    process.stderr.write(`${err?.message ?? String(err)}\n`);
+    process.exit(1);
+  });
+}