@pixelbyte-software/pixcode 1.34.0 → 1.35.1

package/scripts/fix-node-pty.js

@@ -1,67 +1,67 @@
-#!/usr/bin/env node
-/**
- * Fix node-pty spawn-helper permissions on macOS
- *
- * This script fixes a known issue with node-pty where the spawn-helper
- * binary is shipped without execute permissions, causing "posix_spawnp failed" errors.
- *
- * @see https://github.com/microsoft/node-pty/issues/850
- * @module scripts/fix-node-pty
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Fixes the spawn-helper binary permissions for node-pty on macOS.
- *
- * The node-pty package ships the spawn-helper binary without execute permissions
- * (644 instead of 755), which causes "posix_spawnp failed" errors when trying
- * to spawn terminal processes.
- *
- * This function:
- * 1. Checks if running on macOS (darwin)
- * 2. Locates spawn-helper binaries for both arm64 and x64 architectures
- * 3. Sets execute permissions (755) on each binary found
- *
- * @async
- * @function fixSpawnHelper
- * @returns {Promise<void>} Resolves when permissions are fixed or skipped
- * @example
- * // Run as postinstall script
- * await fixSpawnHelper();
- */
-async function fixSpawnHelper() {
-  const nodeModulesPath = path.join(__dirname, '..', 'node_modules', 'node-pty', 'prebuilds');
-
-  // Only run on macOS
-  if (process.platform !== 'darwin') {
-    return;
-  }
-
-  const darwinDirs = ['darwin-arm64', 'darwin-x64'];
-
-  for (const dir of darwinDirs) {
-    const spawnHelperPath = path.join(nodeModulesPath, dir, 'spawn-helper');
-
-    try {
-      // Check if file exists
-      await fs.access(spawnHelperPath);
-
-      // Make it executable (755)
-      await fs.chmod(spawnHelperPath, 0o755);
-      console.log(`[postinstall] Fixed permissions for ${spawnHelperPath}`);
-    } catch (err) {
-      // File doesn't exist or other error - ignore
-      if (err.code !== 'ENOENT') {
-        console.warn(`[postinstall] Warning: Could not fix ${spawnHelperPath}: ${err.message}`);
-      }
-    }
-  }
-}
-
-fixSpawnHelper().catch(console.error);
+#!/usr/bin/env node
+/**
+ * Fix node-pty spawn-helper permissions on macOS
+ *
+ * This script fixes a known issue with node-pty where the spawn-helper
+ * binary is shipped without execute permissions, causing "posix_spawnp failed" errors.
+ *
+ * @see https://github.com/microsoft/node-pty/issues/850
+ * @module scripts/fix-node-pty
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Fixes the spawn-helper binary permissions for node-pty on macOS.
+ *
+ * The node-pty package ships the spawn-helper binary without execute permissions
+ * (644 instead of 755), which causes "posix_spawnp failed" errors when trying
+ * to spawn terminal processes.
+ *
+ * This function:
+ * 1. Checks if running on macOS (darwin)
+ * 2. Locates spawn-helper binaries for both arm64 and x64 architectures
+ * 3. Sets execute permissions (755) on each binary found
+ *
+ * @async
+ * @function fixSpawnHelper
+ * @returns {Promise<void>} Resolves when permissions are fixed or skipped
+ * @example
+ * // Run as postinstall script
+ * await fixSpawnHelper();
+ */
+async function fixSpawnHelper() {
+  const nodeModulesPath = path.join(__dirname, '..', 'node_modules', 'node-pty', 'prebuilds');
+
+  // Only run on macOS
+  if (process.platform !== 'darwin') {
+    return;
+  }
+
+  const darwinDirs = ['darwin-arm64', 'darwin-x64'];
+
+  for (const dir of darwinDirs) {
+    const spawnHelperPath = path.join(nodeModulesPath, dir, 'spawn-helper');
+
+    try {
+      // Check if file exists
+      await fs.access(spawnHelperPath);
+
+      // Make it executable (755)
+      await fs.chmod(spawnHelperPath, 0o755);
+      console.log(`[postinstall] Fixed permissions for ${spawnHelperPath}`);
+    } catch (err) {
+      // File doesn't exist or other error - ignore
+      if (err.code !== 'ENOENT') {
+        console.warn(`[postinstall] Warning: Could not fix ${spawnHelperPath}: ${err.message}`);
+      }
+    }
+  }
+}
+
+fixSpawnHelper().catch(console.error);

package/scripts/smoke/a2a-roundtrip.mjs

@@ -25,6 +25,15 @@ async function jget(path) {
   return r.json();
 }
 
+async function jpost(path, body) {
+  const r = await fetch(`${baseUrl}${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: r.status, json: await r.json() };
+}
+
 async function main() {
   console.log('1) /a2a/.well-known/agent-card.json');
   const card = await jget('/a2a/.well-known/agent-card.json');
@@ -35,28 +44,88 @@ async function main() {
   const agents = await jget('/a2a/agents');
   const ids = agents.agents.map((a) => a.name);
   console.log('   registered:', ids.join(', '));
-  if (!ids.includes('pixcode-claude-code')) {
-    throw new Error('claude-code adapter not registered');
+  const expectedAgents = [
+    'pixcode-claude-code',
+    'pixcode-codex',
+    'pixcode-cursor',
+    'pixcode-gemini',
+    'pixcode-qwen',
+    'pixcode-opencode',
+  ];
+  for (const expected of expectedAgents) {
+    if (!ids.includes(expected)) {
+      throw new Error(`${expected} adapter not registered`);
+    }
   }
 
-  console.log('3) POST /a2a/tasks');
-  const submitRes = await fetch(`${baseUrl}/a2a/tasks`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({
-      adapterId: 'claude-code',
-      message: {
-        messageId: 'm_smoke_1',
-        role: 'user',
-        parts: [{ kind: 'text', text: 'Reply with the single word: ok' }],
-      },
-    }),
+  console.log('3) POST /a2a/adapters/resolve');
+  const resolveRes = await jpost('/a2a/adapters/resolve', {
+    adapterId: 'skill:typescript-edit',
+    routing: { preferredAdapterId: 'codex' },
+  });
+  if (resolveRes.status !== 200) throw new Error(`resolve -> ${resolveRes.status}`);
+  console.log('   resolved=', resolveRes.json.resolvedAdapterId);
+  if (resolveRes.json.resolvedAdapterId !== 'codex') {
+    throw new Error('skill resolution did not honor preferredAdapterId=codex');
+  }
+
+  console.log('4) POST /a2a/tasks (invalid adapter)');
+  const invalidSubmit = await jpost('/a2a/tasks', {
+    adapterId: 'missing-adapter',
+    message: {
+      messageId: 'm_invalid_adapter',
+      role: 'user',
+      parts: [{ kind: 'text', text: 'noop' }],
+    },
   });
-  if (!submitRes.ok) throw new Error(`submit -> ${submitRes.status}`);
-  const task = await submitRes.json();
+  if (invalidSubmit.status !== 404) {
+    throw new Error(`invalid submit -> expected 404, got ${invalidSubmit.status}`);
+  }
+
+  console.log('5) POST /a2a/messages (missing task)');
+  const missingTaskMessage = await jpost('/a2a/messages', {
+    messageId: 'm_missing_task',
+    role: 'user',
+    taskId: 'task_missing',
+    parts: [{ kind: 'text', text: 'noop' }],
+  });
+  if (missingTaskMessage.status !== 404) {
+    throw new Error(`missing task message -> expected 404, got ${missingTaskMessage.status}`);
+  }
+
+  console.log('6) POST /a2a/tasks');
+  const submitRes = await jpost('/a2a/tasks', {
+    adapterId: 'claude-code',
+    message: {
+      messageId: 'm_smoke_1',
+      role: 'user',
+      parts: [{ kind: 'text', text: 'Reply with the single word: ok' }],
+    },
+  });
+  if (submitRes.status !== 202) throw new Error(`submit -> ${submitRes.status}`);
+  const task = submitRes.json;
   console.log('   task.id=', task.id, 'state=', task.state);
+  if (task.history?.[0]?.taskId !== task.id) {
+    throw new Error('task-scoped initial history message is missing taskId');
+  }
+  if (task.metadata?.adapterId !== 'claude-code') {
+    throw new Error('resolved adapterId was not persisted to task metadata');
+  }
+
+  console.log('7) GET /a2a/tasks?adapterId=claude-code&limit=5');
+  const listedTasks = await jget('/a2a/tasks?adapterId=claude-code&limit=5');
+  if (!Array.isArray(listedTasks.tasks) || listedTasks.count < 1) {
+    throw new Error('task listing did not return any tasks');
+  }
+  const listedTask = listedTasks.tasks.find((entry) => entry.id === task.id);
+  if (!listedTask) {
+    throw new Error('submitted task did not appear in filtered task listing');
+  }
+  if (listedTask.adapterId !== 'claude-code') {
+    throw new Error('task summary adapterId mismatch');
+  }
 
-  console.log('4) GET /a2a/tasks/:id/stream (SSE)');
+  console.log('8) GET /a2a/tasks/:id/stream (SSE)');
   const streamRes = await fetch(`${baseUrl}/a2a/tasks/${task.id}/stream`);
   if (!streamRes.ok) throw new Error(`stream -> ${streamRes.status}`);
 

package/scripts/smoke/orchestration-api.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+const baseUrl = process.env.PIXCODE_BASE_URL || 'http://127.0.0.1:3001';
+const apiKey = process.env.PIXCODE_API_KEY;
+
+if (!apiKey) {
+  console.error('PIXCODE_API_KEY is required.');
+  process.exit(1);
+}
+
+async function request(path, options = {}) {
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      'content-type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new Error(`${options.method || 'GET'} ${path} failed: ${response.status} ${text}`);
+  }
+  return body;
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function nodeById(nodes, id) {
+  const node = nodes.find((candidate) => candidate.id === id);
+  assert(node, `Missing workflow node: ${id}`);
+  return node;
+}
+
+function parseJsonEnv(name, fallback) {
+  if (!process.env[name]) return fallback;
+  try {
+    return JSON.parse(process.env[name]);
+  } catch (error) {
+    throw new Error(`${name} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function safeNodeId(adapterId, suffix) {
+  return `${adapterId.replace(/[^a-zA-Z0-9_]+/g, '_')}_${suffix}`;
+}
+
+function safeAgentNodeId(agent, index, suffix) {
+  return `agent_${index + 1}_${safeNodeId(agent.adapterId, suffix)}`;
+}
+
+const smokeAgents = parseJsonEnv('PIXCODE_SMOKE_AGENTS_JSON', [
+  {
+    instanceId: 'codex-frontend',
+    adapterId: 'codex',
+    label: 'Agent #1',
+    role: 'frontend',
+    enabled: true,
+  },
+  {
+    instanceId: 'codex-backend',
+    adapterId: 'codex',
+    label: 'Agent #2',
+    role: 'backend',
+    enabled: true,
+  },
+  {
+    instanceId: 'codex-review',
+    adapterId: 'codex',
+    label: 'Agent #3',
+    role: 'review',
+    enabled: true,
+  },
+]);
+
+const teamMetadata = {
+  agents: smokeAgents,
+  settings: {
+    ...parseJsonEnv('PIXCODE_SMOKE_SETTINGS_JSON', {}),
+    maxParallelAgents: Number.parseInt(process.env.PIXCODE_SMOKE_MAX_PARALLEL || '3', 10),
+    isolation: process.env.PIXCODE_SMOKE_ISOLATION || 'host',
+    keepWorkspace: process.env.PIXCODE_SMOKE_KEEP_WORKSPACE !== 'false',
+  },
+};
+
+async function main() {
+  const health = await fetch(`${baseUrl}/health`).then((response) => response.json());
+  assert(health.status === 'ok', 'Health check did not return ok.');
+
+  const workflows = await request('/api/orchestration/workflows');
+  assert(Array.isArray(workflows.workflows), 'Workflow list payload is invalid.');
+  assert(workflows.workflows.some((workflow) => workflow.id === 'agent_team'), 'agent_team workflow is missing.');
+
+  const preview = await request('/api/orchestration/workflows/agent_team/preview', {
+    method: 'POST',
+    body: JSON.stringify({ metadata: teamMetadata }),
+  });
+  assert(preview.workflow?.id === 'agent_team', 'Preview did not return the agent_team workflow.');
+  assert(preview.nodeCount === preview.nodes.length, 'Preview nodeCount does not match nodes length.');
+
+  const backendIndex = smokeAgents.findIndex((agent) => agent.role === 'backend');
+  const frontendIndex = smokeAgents.findIndex((agent) => agent.role === 'frontend');
+  const reviewIndex = smokeAgents.findIndex((agent) => agent.role === 'review');
+  assert(backendIndex >= 0, 'Smoke agents must include one role=backend agent.');
+  assert(frontendIndex >= 0, 'Smoke agents must include one role=frontend agent.');
+  assert(reviewIndex >= 0, 'Smoke agents must include one role=review agent.');
+
+  const backendAgent = smokeAgents[backendIndex];
+  const frontendAgent = smokeAgents[frontendIndex];
+  const reviewAgent = smokeAgents[reviewIndex];
+  const backendHandoffId = safeAgentNodeId(backendAgent, backendIndex, 'handoff');
+  const backendWorkId = safeAgentNodeId(backendAgent, backendIndex, 'work');
+  const frontendWorkId = safeAgentNodeId(frontendAgent, frontendIndex, 'work');
+  const reviewWorkId = safeAgentNodeId(reviewAgent, reviewIndex, 'work');
+
+  const backendHandoff = nodeById(preview.nodes, backendHandoffId);
+  const backendWork = nodeById(preview.nodes, backendWorkId);
+  const frontendWork = nodeById(preview.nodes, frontendWorkId);
+  const reviewWork = nodeById(preview.nodes, reviewWorkId);
+  const finalReport = nodeById(preview.nodes, 'final_report');
+
+  assert(backendHandoff.timeoutMs === 120000, 'Backend handoff timeout is not set to 120000ms.');
+  assert(backendHandoff.inputs.includes('coordinator'), 'Backend handoff must depend on coordinator.');
+  assert(backendWork.inputs.includes(backendHandoffId), 'Backend work must depend on backend handoff.');
+  assert(frontendWork.inputs.includes(backendHandoffId), 'Frontend work must depend on backend handoff.');
+  assert(!frontendWork.inputs.includes(backendWorkId), 'Frontend must not wait for full backend implementation.');
+  assert(reviewWork.inputs.includes(frontendWorkId), 'Review must depend on frontend work.');
+  assert(reviewWork.inputs.includes(backendWorkId), 'Review must depend on backend work.');
+  assert(finalReport.inputs.includes(reviewWorkId), 'Final report must include review output.');
+
+  const runs = await request('/api/orchestration/workflows/runs?limit=5');
+  assert(Array.isArray(runs.runs), 'Runs payload is invalid.');
+
+  let eventsChecked = false;
+  if (runs.runs[0]?.id) {
+    const controller = new AbortController();
+    const response = await fetch(
+      `${baseUrl}/api/orchestration/workflows/runs/${encodeURIComponent(runs.runs[0].id)}/events`,
+      {
+        headers: { authorization: `Bearer ${apiKey}` },
+        signal: controller.signal,
+      },
+    );
+    assert(response.ok, `Run events endpoint returned ${response.status}.`);
+    assert(response.body, 'Run events endpoint did not return a readable body.');
+    const reader = response.body.getReader();
+    const firstChunk = await reader.read();
+    controller.abort();
+    const eventText = new TextDecoder().decode(firstChunk.value || new Uint8Array());
+    assert(eventText.includes('event: snapshot'), 'Run events endpoint did not emit an initial snapshot.');
+    eventsChecked = true;
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    baseUrl,
+    workflowCount: workflows.workflows.length,
+    previewNodeIds: preview.nodes.map((node) => node.id),
+    recentRunCount: runs.runs.length,
+    eventsChecked,
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/scripts/smoke/orchestration-live-run.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+const baseUrl = process.env.PIXCODE_BASE_URL || 'http://127.0.0.1:3001';
+const apiKey = process.env.PIXCODE_API_KEY;
+const goal = process.env.PIXCODE_LIVE_GOAL;
+const timeoutMs = Number.parseInt(process.env.PIXCODE_LIVE_TIMEOUT_MS || '1200000', 10);
+const minAgentOutputs = Number.parseInt(process.env.PIXCODE_LIVE_MIN_AGENT_OUTPUTS || '2', 10);
+const workflowId = process.env.PIXCODE_LIVE_WORKFLOW_ID || 'agent_team';
+
+if (!apiKey) {
+  console.error('PIXCODE_API_KEY is required.');
+  process.exit(1);
+}
+
+if (!goal) {
+  console.error('PIXCODE_LIVE_GOAL is required.');
+  process.exit(1);
+}
+
+function parseJsonEnv(name) {
+  const raw = process.env[name];
+  if (!raw) {
+    throw new Error(`${name} is required.`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${name} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function headers(extra = {}) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    'content-type': 'application/json',
+    ...extra,
+  };
+}
+
+async function request(path, options = {}) {
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: headers(options.headers || {}),
+  });
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new Error(`${options.method || 'GET'} ${path} failed: ${response.status} ${text}`);
+  }
+  return body;
+}
+
+function terminal(status) {
+  return status === 'completed' || status === 'failed' || status === 'canceled';
+}
+
+function agentTextCount(run) {
+  return (run.nodeRuns || []).filter((node) =>
+    (node.messages || []).some((message) => message.role !== 'user' && message.text?.trim()) ||
+    Boolean(node.outputText?.trim()),
+  ).length;
+}
+
+function compactNodes(run) {
+  return (run.nodeRuns || []).map((node) => ({
+    nodeId: node.nodeId,
+    label: node.agentLabel,
+    status: node.status,
+    taskId: node.a2aTaskId,
+    messageCount: (node.messages || []).filter((message) => message.role !== 'user').length,
+    hasOutput: Boolean(node.outputText?.trim()),
+    error: node.error,
+  }));
+}
+
+async function cancelRun(runId) {
+  try {
+    await request(`/api/orchestration/workflows/runs/${encodeURIComponent(runId)}/cancel`, {
+      method: 'POST',
+      body: '{}',
+    });
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+async function main() {
+  const agents = parseJsonEnv('PIXCODE_LIVE_AGENTS_JSON');
+  assert(Array.isArray(agents) && agents.length > 0, 'PIXCODE_LIVE_AGENTS_JSON must be a non-empty array.');
+
+  const settings = process.env.PIXCODE_LIVE_SETTINGS_JSON
+    ? JSON.parse(process.env.PIXCODE_LIVE_SETTINGS_JSON)
+    : {};
+  const metadata = {
+    agents,
+    projectPath: process.env.PIXCODE_LIVE_PROJECT_PATH,
+    projectId: process.env.PIXCODE_LIVE_PROJECT_ID,
+    settings: {
+      maxParallelAgents: Number.parseInt(process.env.PIXCODE_LIVE_MAX_PARALLEL || '3', 10),
+      isolation: process.env.PIXCODE_LIVE_ISOLATION || 'host',
+      keepWorkspace: process.env.PIXCODE_LIVE_KEEP_WORKSPACE !== 'false',
+      ...settings,
+    },
+  };
+
+  const preview = await request(`/api/orchestration/workflows/${encodeURIComponent(workflowId)}/preview`, {
+    method: 'POST',
+    body: JSON.stringify({ metadata }),
+  });
+  assert(preview.nodeCount >= agents.length + 1, 'Preview did not expand enough nodes for the requested agents.');
+  console.log(JSON.stringify({ event: 'preview', nodeIds: preview.nodes.map((node) => node.id) }));
+
+  const started = await request(`/api/orchestration/workflows/${encodeURIComponent(workflowId)}/runs`, {
+    method: 'POST',
+    body: JSON.stringify({ input: goal, metadata }),
+  });
+  const runId = started.id;
+  assert(runId, 'Run id missing from start response.');
+  console.log(JSON.stringify({ event: 'started', runId, contextId: started.contextId }));
+
+  const deadline = Date.now() + timeoutMs;
+  let lastSignature = '';
+  let latest = started;
+  while (!terminal(latest.status) && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    latest = await request(`/api/orchestration/workflows/runs/${encodeURIComponent(runId)}`);
+    const nodes = compactNodes(latest);
+    const signature = JSON.stringify(nodes.map((node) => [
+      node.nodeId,
+      node.status,
+      node.messageCount,
+      node.hasOutput,
+      node.error,
+    ]));
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      console.log(JSON.stringify({
+        event: 'progress',
+        status: latest.status,
+        agentOutputs: agentTextCount(latest),
+        nodes,
+      }));
+    }
+  }
+
+  if (!terminal(latest.status)) {
+    await cancelRun(runId);
+    throw new Error(`Run ${runId} did not finish before ${timeoutMs}ms; canceled.`);
+  }
+
+  const outputCount = agentTextCount(latest);
+  if (outputCount < minAgentOutputs) {
+    throw new Error(`Expected at least ${minAgentOutputs} nodes with agent output; got ${outputCount}.`);
+  }
+
+  if (latest.status !== 'completed') {
+    throw new Error(`Run ended with ${latest.status}: ${JSON.stringify(compactNodes(latest))}`);
+  }
+
+  console.log(JSON.stringify({
+    event: 'completed',
+    runId,
+    contextId: latest.contextId,
+    outputCount,
+    nodes: compactNodes(latest),
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});