@pixelbyte-software/pixcode 1.42.5 → 1.44.0

package/server/modules/orchestration/workflows/workflow.routes.ts

@@ -14,6 +14,11 @@ import {
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
 import { buildWorkflowTrace } from '@/modules/orchestration/workflows/workflow-trace.js';
 import { findPixcodeAppRoot } from '@/modules/orchestration/workflows/workspace-target.js';
+import {
+  listPendingApprovals,
+  resolvePermissionApproval,
+  type ApprovalDecisionSource,
+} from '@/modules/orchestration/workflows/approval-queue.js';
 import {
   DEFAULT_PERMISSION_POLICY,
   PERMISSION_CAPABILITIES,
@@ -22,6 +27,7 @@ import {
   evaluatePermissionRequest,
   normalizePermissionPolicy,
 } from '@/modules/orchestration/security/permission-policy.js';
+import { dispatchWebhookEvent } from '@/services/webhooks.js';
 
 const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
 
@@ -254,6 +260,55 @@ export function createWorkflowRouter(): Router {
     });
   });
 
+  router.get('/workflows/approvals', (req, res) => {
+    res.json({
+      pendingApprovals: listPendingApprovals({
+        projectId: readOptionalString(req.query.projectId),
+        includeResolved: readBooleanFlag(req.query.includeResolved),
+      }),
+    });
+  });
+
+  router.post('/workflows/approvals/:approvalId', (req, res) => {
+    const allow = req.body?.allow === true;
+    const deny = req.body?.allow === false;
+    if (!allow && !deny) {
+      res.status(400).json({
+        error: {
+          code: 'PERMISSION_DECISION_REQUIRED',
+          message: 'Approval queue decisions require allow=true or allow=false.',
+        },
+      });
+      return;
+    }
+
+    const source = ['ui', 'telegram', 'api'].includes(req.body?.source)
+      ? req.body.source as ApprovalDecisionSource
+      : 'api';
+    const result = resolvePermissionApproval({
+      approvalId: req.params.approvalId,
+      allow,
+      source,
+      resolvedBy: readRequestUserId(req),
+      message: readOptionalString(req.body?.message),
+    });
+    if (!result) {
+      res.status(404).json({ error: { code: 'APPROVAL_NOT_FOUND', message: req.params.approvalId } });
+      return;
+    }
+
+    dispatchWebhookEvent({
+      type: 'approval.resolved',
+      payload: {
+        approvalId: req.params.approvalId,
+        allow,
+        source,
+        runId: result.runId,
+      },
+    });
+    res.json(result);
+  });
+
   router.post('/workflows/runs/:runId/permission-approvals/:requestId', (req, res) => {
     const run = workflowStore.getRun(req.params.runId);
     if (!run) {
@@ -285,6 +340,15 @@ export function createWorkflowRouter(): Router {
     }
 
     workflowStore.setRun(run);
+    dispatchWebhookEvent({
+      type: 'approval.resolved',
+      payload: {
+        approvalId: req.params.requestId,
+        allow,
+        source: 'ui',
+        runId: run.id,
+      },
+    });
     res.json({
       runId: run.id,
       pendingApprovals: readRunArray(run, 'pendingPermissionApprovals')
@@ -359,6 +423,14 @@ export function createWorkflowRouter(): Router {
           },
         },
       );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: replayRun.id,
+          workflowId: replayRun.workflowId,
+          replayOf: run.id,
+        },
+      });
       res.status(202).json({
         run: replayRun,
         replayPlan,
@@ -424,6 +496,13 @@ export function createWorkflowRouter(): Router {
       res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
       return;
     }
+    dispatchWebhookEvent({
+      type: 'run.canceled',
+      payload: {
+        runId: run.id,
+        workflowId: run.workflowId,
+      },
+    });
     res.json(run);
   });
 
@@ -443,6 +522,14 @@ export function createWorkflowRouter(): Router {
           workflowName: workflow.name,
         },
       );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: run.id,
+          workflowId: run.workflowId,
+          workflowName: workflow.name,
+        },
+      });
       res.status(202).json(run);
     } catch (error) {
       res.status(400).json({
@@ -476,6 +563,14 @@ export function createWorkflowRouter(): Router {
           workflowName: workflow.name,
         },
       );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: run.id,
+          workflowId: run.workflowId,
+          templateId: template.id,
+        },
+      });
       res.status(202).json(run);
     } catch (error) {
       res.status(400).json({

package/server/routes/production-agent-loop.js

@@ -0,0 +1,90 @@
+import express from 'express';
+
+import {
+  createIssueToPrRun,
+  createReviewQueueItem,
+  createWorkspaceCheckpoint,
+  evaluateDesktopReleaseAssetPolicy,
+  getProductionAgentLoopState,
+  parseCiRepairSignals,
+  scheduleBackgroundAgentJob,
+  updateReviewQueueItem,
+} from '../services/production-agent-loop.js';
+
+const router = express.Router();
+
+function userId(req) {
+  return req.user?.id ?? req.user?.userId ?? null;
+}
+
+router.get('/', (_req, res) => {
+  res.json({ success: true, state: getProductionAgentLoopState() });
+});
+
+router.post('/github/issue-to-pr', (req, res) => {
+  try {
+    const run = createIssueToPrRun(req.body || {}, userId(req));
+    res.status(202).json({ success: true, run });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/ci/repair-plan', (req, res) => {
+  res.json({
+    success: true,
+    repairPlan: parseCiRepairSignals(req.body?.log || req.body?.output || ''),
+  });
+});
+
+router.get('/review-queue', (_req, res) => {
+  res.json({ success: true, reviewQueue: getProductionAgentLoopState().reviewQueue });
+});
+
+router.post('/review-queue', (req, res) => {
+  const item = createReviewQueueItem(req.body || {}, userId(req));
+  res.status(201).json({ success: true, item });
+});
+
+router.patch('/review-queue/:id', (req, res) => {
+  const item = updateReviewQueueItem(req.params.id, req.body || {});
+  if (!item) {
+    res.status(404).json({ success: false, error: 'Review queue item not found.' });
+    return;
+  }
+  res.json({ success: true, item });
+});
+
+router.get('/scheduler/jobs', (_req, res) => {
+  res.json({ success: true, jobs: getProductionAgentLoopState().schedulerJobs });
+});
+
+router.post('/scheduler/jobs', (req, res) => {
+  const job = scheduleBackgroundAgentJob(req.body || {}, userId(req));
+  res.status(201).json({ success: true, job });
+});
+
+router.get('/snapshots', (_req, res) => {
+  res.json({ success: true, checkpoints: getProductionAgentLoopState().checkpoints });
+});
+
+router.post('/snapshots', (req, res) => {
+  const checkpoint = createWorkspaceCheckpoint(req.body || {}, userId(req));
+  res.status(201).json({ success: true, checkpoint });
+});
+
+router.post('/desktop-release/assets-policy', (req, res) => {
+  res.json({
+    success: true,
+    policy: evaluateDesktopReleaseAssetPolicy(req.body?.assets || req.body?.assetNames || []),
+  });
+});
+
+router.get('/desktop-release/assets-policy', (_req, res) => {
+  res.json({
+    success: true,
+    policy: evaluateDesktopReleaseAssetPolicy([]),
+  });
+});
+
+export default router;

package/server/routes/public-api.js

@@ -1,6 +1,11 @@
 import express from 'express';
 
-import { buildOpenApiFragment, buildPublicApiManifest } from '../services/public-api-manifest.js';
+import {
+  buildCurlCookbook,
+  buildOpenApiFragment,
+  buildPublicApiManifest,
+  buildTypeScriptSdkStarter,
+} from '../services/public-api-manifest.js';
 
 const router = express.Router();
 
@@ -18,4 +23,12 @@ router.get('/openapi', (req, res) => {
   res.json(buildOpenApiFragment({ baseUrl: requestBaseUrl(req) }));
 });
 
+router.get('/sdk/typescript', (req, res) => {
+  res.type('text/typescript').send(buildTypeScriptSdkStarter({ baseUrl: requestBaseUrl(req) }));
+});
+
+router.get('/cookbook', (req, res) => {
+  res.json(buildCurlCookbook({ baseUrl: requestBaseUrl(req) }));
+});
+
 export default router;

package/server/routes/remote.js

@@ -5,6 +5,10 @@ import {
   getPublicRemoteConnectionConfig,
   saveRemoteConnectionConfig,
 } from '../services/remote-connection.js';
+import {
+  buildControlRoomSnapshot,
+  buildMobileConsoleLayout,
+} from '../services/control-room.js';
 
 const router = express.Router();
 
@@ -30,4 +34,22 @@ router.post('/check', async (req, res) => {
   }
 });
 
+router.get('/control-room', async (_req, res) => {
+  try {
+    res.json({
+      success: true,
+      controlRoom: await buildControlRoomSnapshot(),
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/console-layout', (_req, res) => {
+  res.json({
+    success: true,
+    layout: buildMobileConsoleLayout(),
+  });
+});
+
 export default router;

package/server/routes/webhooks.js

@@ -0,0 +1,63 @@
+import express from 'express';
+
+import {
+  PIXCODE_WEBHOOK_EVENT_TYPES,
+  deleteWebhook,
+  deliverWebhookEvent,
+  listWebhooks,
+  upsertWebhook,
+} from '../services/webhooks.js';
+
+const router = express.Router();
+
+router.get('/', (_req, res) => {
+  res.json({
+    success: true,
+    eventTypes: PIXCODE_WEBHOOK_EVENT_TYPES,
+    webhooks: listWebhooks(),
+  });
+});
+
+router.post('/', (req, res) => {
+  try {
+    const webhook = upsertWebhook(req.body || {});
+    res.status(201).json({ success: true, webhook });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.patch('/:id', (req, res) => {
+  try {
+    const webhook = upsertWebhook({ ...(req.body || {}), id: req.params.id });
+    res.json({ success: true, webhook });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/:id', (req, res) => {
+  if (!deleteWebhook(req.params.id)) {
+    res.status(404).json({ success: false, error: 'Webhook not found.' });
+    return;
+  }
+  res.json({ success: true });
+});
+
+router.post('/test', async (req, res) => {
+  try {
+    const result = await deliverWebhookEvent({
+      type: req.body?.type || 'run.completed',
+      payload: {
+        test: true,
+        message: 'Pixcode webhook test delivery',
+        sentBy: req.user?.id ?? null,
+      },
+    });
+    res.json({ success: true, result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/services/control-room.js

@@ -0,0 +1,102 @@
+import { listPendingApprovals, workflowStore } from '../modules/orchestration/index.js';
+import { getProjects } from '../projects.js';
+
+import { listWebhooks } from './webhooks.js';
+
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+
+function projectPath(project) {
+  return project.fullPath || project.path || '';
+}
+
+function runBelongsToProject(run, project) {
+  const projectId = run.metadata?.projectId;
+  const path = run.metadata?.projectPath;
+  return projectId === project.name || path === projectPath(project);
+}
+
+function countSessions(project) {
+  return [
+    project.sessions,
+    project.codexSessions,
+    project.cursorSessions,
+    project.geminiSessions,
+    project.qwenSessions,
+    project.opencodeSessions,
+  ].reduce((total, sessions) => total + (Array.isArray(sessions) ? sessions.length : 0), 0);
+}
+
+function summarizeProject(project, runs, approvals) {
+  const projectRuns = runs.filter((run) => runBelongsToProject(run, project));
+  const runningRuns = projectRuns.filter((run) => !TERMINAL_RUN_STATES.has(run.status));
+  const failedRuns = projectRuns.filter((run) => run.status === 'failed');
+  const projectApprovals = approvals.filter((approval) => (
+    approval.runId && projectRuns.some((run) => run.id === approval.runId)
+  ));
+
+  return {
+    id: project.name,
+    name: project.displayName || project.name,
+    path: projectPath(project),
+    sessionCount: countSessions(project),
+    activeRunCount: runningRuns.length,
+    failedRunCount: failedRuns.length,
+    pendingApprovalCount: projectApprovals.length,
+    latestRuns: projectRuns.slice(0, 4).map((run) => ({
+      id: run.id,
+      workflowId: run.workflowId,
+      status: run.status,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt,
+    })),
+  };
+}
+
+export async function buildControlRoomSnapshot({ maxProjects = 4 } = {}) {
+  const projects = await getProjects();
+  const runs = workflowStore.listRuns();
+  const pendingApprovals = listPendingApprovals();
+  const webhooks = listWebhooks();
+  const projectCards = projects
+    .map((project) => summarizeProject(project, runs, pendingApprovals))
+    .sort((a, b) => (
+      b.pendingApprovalCount - a.pendingApprovalCount ||
+      b.activeRunCount - a.activeRunCount ||
+      b.failedRunCount - a.failedRunCount ||
+      a.name.localeCompare(b.name)
+    ))
+    .slice(0, maxProjects);
+
+  return {
+    protocol: 'pixcode.control-room.v1',
+    generatedAt: new Date().toISOString(),
+    maxProjects,
+    mobileFirst: true,
+    totals: {
+      projects: projects.length,
+      activeRuns: runs.filter((run) => !TERMINAL_RUN_STATES.has(run.status)).length,
+      failedRuns: runs.filter((run) => run.status === 'failed').length,
+      pendingApprovals: pendingApprovals.length,
+      webhooks: webhooks.length,
+      enabledWebhooks: webhooks.filter((webhook) => webhook.enabled).length,
+    },
+    projects: projectCards,
+    approvals: pendingApprovals.slice(0, 20),
+    webhooks,
+  };
+}
+
+export function buildMobileConsoleLayout() {
+  return {
+    protocol: 'pixcode.remote-console-layout.v1',
+    mobileFirst: true,
+    sections: [
+      { id: 'projects', title: 'Projects', priority: 1 },
+      { id: 'approvals', title: 'Approval queue', priority: 2 },
+      { id: 'runs', title: 'Runs', priority: 3 },
+      { id: 'webhooks', title: 'Webhooks', priority: 4 },
+      { id: 'api', title: 'API SDK', priority: 5 },
+    ],
+    maxVisibleProjects: 4,
+  };
+}