@synth-deploy/server 1.1.0 → 1.2.0

package/dist/api/operations.js

@@ -140,16 +140,12 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                     // Trigger operations: construct MonitoringDirective from plan, present for approval
                     if (dep.input.type === "trigger" && !result.blocked) {
                         const triggerInput = dep.input;
-                        // Convert plan steps to monitoring probes
-                        const probes = result.plan.steps.map((step) => ({
-                            command: step.action,
-                            label: step.description,
-                            parseAs: (step.params?.parseAs === "exitCode" ? "exitCode" : "numeric"),
-                        }));
+                        // Use probes from the envoy's trigger planning response (embedded in scriptedPlan reasoning),
+                        // or fall back to a default probe. The envoy's planTrigger generates these.
                         const directive = {
                             id: dep.id,
                             operationId: dep.id,
-                            probes: probes.length > 0 ? probes : [{
+                            probes: [{
                                     command: "echo 0",
                                     label: "default-probe",
                                     parseAs: "numeric",
@@ -159,7 +155,6 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                             condition: triggerInput.condition,
                             responseIntent: triggerInput.responseIntent,
                             responseType: "maintain",
-                            responseParameters: triggerInput.parameters,
                             environmentId: dep.environmentId,
                             partitionId: dep.partitionId,
                             status: "active",
@@ -218,7 +213,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                             decisionType: "plan-generation",
                             decision: `Operation plan blocked — infrastructure prerequisites not met`,
                             reasoning: result.blockReason ?? result.plan.reasoning,
-                            context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, blocked: true },
+                            context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, blocked: true },
                         });
                     }
                     else {
@@ -231,9 +226,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                             operationId: dep.id,
                             agent: "envoy",
                             decisionType: "plan-generation",
-                            decision: `Operation plan generated with ${result.plan.steps.length} steps`,
+                            decision: `Operation plan generated with ${result.plan.scriptedPlan.stepSummary.length} steps`,
                             reasoning: result.plan.reasoning,
-                            context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, delta: result.delta },
+                            context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, delta: result.delta },
                         });
                     }
                 }).catch((err) => {
@@ -331,9 +326,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             operationId: deployment.id,
             agent: "envoy",
             decisionType: "plan-generation",
-            decision: `Operation plan submitted with ${parsed.data.plan.steps.length} steps`,
+            decision: `Operation plan submitted with ${parsed.data.plan.scriptedPlan.stepSummary.length} steps`,
             reasoning: parsed.data.plan.reasoning,
-            context: { stepCount: parsed.data.plan.steps.length },
+            context: { stepCount: parsed.data.plan.scriptedPlan.stepSummary.length },
         });
         return reply.status(200).send({ deployment });
     });
@@ -376,7 +371,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             target: { type: "deployment", id: deployment.id },
             details: parsed.data.modifications
                 ? { modifications: parsed.data.modifications }
-                : { planStepCount: deployment.plan?.steps.length ?? 0 },
+                : { planStepCount: deployment.plan?.scriptedPlan.stepSummary.length ?? 0 },
         });
         // Composite operations: execute children sequentially
         if (deployment.input.type === "composite") {
@@ -530,9 +525,14 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             return reply.status(409).send({ error: "Operation has no plan to modify" });
         }
         // Validate modified plan with envoy if available
-        if (envoyClient) {
+        if (envoyClient && deployment.plan.scriptedPlan) {
             try {
-                const validation = await envoyClient.validatePlan(parsed.data.steps);
+                const modifiedScript = {
+                    ...deployment.plan.scriptedPlan,
+                    executionScript: parsed.data.executionScript,
+                    ...(parsed.data.rollbackScript !== undefined ? { rollbackScript: parsed.data.rollbackScript } : {}),
+                };
+                const validation = await envoyClient.validatePlan(modifiedScript);
                 if (!validation.valid) {
                     return reply.status(422).send({
                         error: "Modified plan failed envoy validation",
@@ -544,35 +544,20 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                 // Envoy unreachable — proceed without validation but note it
             }
         }
-        // Build structured diff: what changed between old and new steps
-        const oldSteps = deployment.plan.steps;
-        const newSteps = parsed.data.steps;
-        const diffLines = [];
-        const maxLen = Math.max(oldSteps.length, newSteps.length);
-        for (let i = 0; i < maxLen; i++) {
-            const old = oldSteps[i];
-            const cur = newSteps[i];
-            if (!old) {
-                diffLines.push(`+ Step ${i + 1} (added): ${cur.action} ${cur.target} — ${cur.description}`);
-            }
-            else if (!cur) {
-                diffLines.push(`- Step ${i + 1} (removed): ${old.action} ${old.target} — ${old.description}`);
-            }
-            else if (old.action !== cur.action || old.target !== cur.target || old.description !== cur.description) {
-                diffLines.push(`~ Step ${i + 1} (changed): ${old.action} ${old.target} → ${cur.action} ${cur.target}`);
-                if (old.description !== cur.description) {
-                    diffLines.push(`  was: ${old.description}`);
-                    diffLines.push(`  now: ${cur.description}`);
-                }
-            }
-        }
-        const diffFromPreviousPlan = diffLines.length > 0
-            ? diffLines.join("\n")
-            : "Steps reordered or metadata changed (actions and targets unchanged)";
+        // Compute diff description
+        const oldScript = deployment.plan.scriptedPlan?.executionScript ?? "";
+        const newScript = parsed.data.executionScript;
+        const diffFromPreviousPlan = oldScript !== newScript
+            ? "Execution script modified by user"
+            : "Plan metadata changed (script unchanged)";
         // Apply modifications
         deployment.plan = {
             ...deployment.plan,
-            steps: parsed.data.steps,
+            scriptedPlan: {
+                ...deployment.plan.scriptedPlan,
+                executionScript: parsed.data.executionScript,
+                ...(parsed.data.rollbackScript !== undefined ? { rollbackScript: parsed.data.rollbackScript } : {}),
+            },
             diffFromPreviousPlan,
         };
         deployments.save(deployment);
@@ -587,7 +572,6 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             reasoning: parsed.data.reason,
             context: {
                 modifiedBy: actor,
-                stepCount: parsed.data.steps.length,
                 reason: parsed.data.reason,
             },
             actor: request.user?.email,
@@ -596,13 +580,13 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             actor,
             action: "operation.modified",
             target: { type: "deployment", id: deployment.id },
-            details: { reason: parsed.data.reason, stepCount: parsed.data.steps.length },
+            details: { reason: parsed.data.reason },
         });
         telemetry.record({
             actor,
             action: "agent.recommendation.overridden",
             target: { type: "deployment", id: deployment.id },
-            details: { reason: parsed.data.reason, stepCount: parsed.data.steps.length, diff: diffFromPreviousPlan },
+            details: { reason: parsed.data.reason, diff: diffFromPreviousPlan },
         });
         return { deployment, modified: true };
     });
@@ -635,10 +619,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
         try {
             const validation = await planningClientForValidation.validateRefinementFeedback({
                 feedback: parsed.data.feedback,
-                currentPlanSteps: (deployment.plan?.steps ?? []).map((s) => ({
+                currentPlanSummary: (deployment.plan?.scriptedPlan?.stepSummary ?? []).map((s) => ({
                     description: s.description,
-                    action: s.action,
-                    target: s.target,
+                    reversible: s.reversible,
                 })),
                 artifactName: artifact?.name ?? "unknown",
                 environmentName: environment?.name ?? "unknown",
@@ -707,9 +690,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             operationId: dep.id,
             agent: "envoy",
             decisionType: "plan-generation",
-            decision: `Plan regenerated with user feedback (${result.plan.steps.length} steps)`,
+            decision: `Plan regenerated with user feedback (${result.plan.scriptedPlan.stepSummary.length} steps)`,
             reasoning: result.plan.reasoning,
-            context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, refinementFeedback: parsed.data.feedback },
+            context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, refinementFeedback: parsed.data.feedback },
         });
         return { deployment: dep, replanned: true };
     });
@@ -785,17 +768,17 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             return reply.status(503).send({ error: "No envoy available to generate rollback plan" });
         }
         const environment = deployment.environmentId ? environments.get(deployment.environmentId) : undefined;
-        // Build the list of completed steps from execution record (or plan as fallback)
+        // Build the list of completed steps from execution record (or plan step summaries as fallback)
         const completedSteps = deployment.executionRecord?.steps.map((s) => ({
             description: s.description,
-            action: deployment.plan?.steps.find((p) => p.description === s.description)?.action ?? "unknown",
-            target: deployment.plan?.steps.find((p) => p.description === s.description)?.target ?? "",
+            action: "script-step",
+            target: "",
             status: s.status,
             output: s.output ?? s.error,
-        })) ?? deployment.plan?.steps.map((s) => ({
+        })) ?? deployment.plan?.scriptedPlan?.stepSummary.map((s) => ({
             description: s.description,
-            action: s.action,
-            target: s.target,
+            action: "script-step",
+            target: "",
             status: "completed",
         })) ?? [];
         const rollbackClient = new EnvoyClient(targetEnvoy.url);
@@ -835,7 +818,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                 reasoning: rollbackPlan.reasoning,
                 context: {
                     requestedBy: actor,
-                    stepCount: rollbackPlan.steps.length,
+                    stepCount: rollbackPlan.scriptedPlan.stepSummary.length,
                     envoyId: targetEnvoy.id,
                     deploymentStatus: deployment.status,
                 },
@@ -845,7 +828,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                 actor,
                 action: "deployment.rollback-plan-requested",
                 target: { type: "deployment", id: deployment.id },
-                details: { stepCount: rollbackPlan.steps.length },
+                details: { stepCount: rollbackPlan.scriptedPlan.stepSummary.length },
             });
             return reply.status(200).send({ deployment, rollbackPlan });
         }
@@ -890,20 +873,30 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             agent: "server",
             decisionType: "rollback-execution",
             decision: `Rollback execution initiated for ${artifact?.name ?? getArtifactId(deployment)} v${deployment.version}`,
-            reasoning: `Rollback requested by ${actor}. Executing ${deployment.rollbackPlan.steps.length} rollback step(s).`,
-            context: { initiatedBy: actor, stepCount: deployment.rollbackPlan.steps.length },
+            reasoning: `Rollback requested by ${actor}. Executing ${deployment.rollbackPlan.scriptedPlan.stepSummary.length} rollback step(s).`,
+            context: { initiatedBy: actor, stepCount: deployment.rollbackPlan.scriptedPlan.stepSummary.length },
             actor: request.user?.email,
         });
         telemetry.record({
             actor,
             action: "deployment.rollback-executed",
             target: { type: "deployment", id: deployment.id },
-            details: { stepCount: deployment.rollbackPlan.steps.length },
+            details: { stepCount: deployment.rollbackPlan.scriptedPlan.stepSummary.length },
         });
         const rollbackClient = new EnvoyClient(targetEnvoy.url);
         // Execute the rollback plan as if it were a forward plan — it IS a forward plan
         // (just in the reverse direction). Use an empty no-op plan as the "rollback of rollback".
-        const emptyPlan = { steps: [], reasoning: "No rollback of rollback." };
+        const emptyPlan = {
+            scriptedPlan: {
+                platform: "bash",
+                executionScript: "# No rollback of rollback",
+                dryRunScript: null,
+                rollbackScript: null,
+                reasoning: "No rollback of rollback.",
+                stepSummary: [],
+            },
+            reasoning: "No rollback of rollback.",
+        };
         rollbackClient.executeApprovedPlan({
             operationId: deployment.id,
             plan: deployment.rollbackPlan,
@@ -1059,7 +1052,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                             decisionType: "plan-generation",
                             decision: `Operation plan blocked — infrastructure prerequisites not met`,
                             reasoning: result.blockReason ?? result.plan.reasoning,
-                            context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, blocked: true },
+                            context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, blocked: true },
                         });
                     }
                     else {
@@ -1071,9 +1064,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                             operationId: dep.id,
                             agent: "envoy",
                             decisionType: "plan-generation",
-                            decision: `Operation plan generated with ${result.plan.steps.length} steps`,
+                            decision: `Operation plan generated with ${result.plan.scriptedPlan.stepSummary.length} steps`,
                             reasoning: result.plan.reasoning,
-                            context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, delta: result.delta },
+                            context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, delta: result.delta },
                         });
                     }
                 }).catch((err) => {
@@ -1296,7 +1289,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
             id: crypto.randomUUID(),
             input: responseType === "deploy"
                 ? { type: "deploy", artifactId: "" }
-                : { type: "maintain", intent: triggerInput.responseIntent, parameters: triggerInput.parameters },
+                : { type: "maintain", intent: triggerInput.responseIntent },
             intent: triggerInput.responseIntent,
             lineage: triggerOp.id,
             triggeredBy: "trigger",
@@ -1597,9 +1590,9 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                     operationId: childDep.id,
                     agent: "envoy",
                     decisionType: "plan-generation",
-                    decision: `Child operation plan generated with ${result.plan.steps.length} steps`,
+                    decision: `Child operation plan generated with ${result.plan.scriptedPlan.stepSummary.length} steps`,
                     reasoning: result.plan.reasoning,
-                    context: { stepCount: result.plan.steps.length, envoyId: planningEnvoy.id, parentOperationId: parentOp.id },
+                    context: { stepCount: result.plan.scriptedPlan.stepSummary.length, envoyId: planningEnvoy.id, parentOperationId: parentOp.id },
                 });
             }
             catch (err) {
@@ -1631,19 +1624,43 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
         if (!anyFailed) {
             // All children planned — build combined summary plan and await approval
             const allChildren = childIds.map((id) => deployments.get(id)).filter(Boolean);
-            const combinedSteps = allChildren.flatMap((c, idx) => {
-                if (!c.plan)
+            const combinedStepSummary = allChildren.flatMap((c, idx) => {
+                if (!c.plan?.scriptedPlan)
                     return [];
-                return c.plan.steps.map((step) => ({
+                return c.plan.scriptedPlan.stepSummary.map((step) => ({
                     ...step,
                     description: `[${idx + 1}/${allChildren.length}: ${c.input.type}] ${step.description}`,
                 }));
             });
             const combinedReasoning = allChildren.map((c, idx) => `Step ${idx + 1} (${c.input.type}): ${c.plan?.reasoning ?? "no reasoning"}`).join("\n\n");
+            // Combine child execution scripts into a single composite script
+            const combinedScript = allChildren
+                .map((c, idx) => `# --- Child ${idx + 1}/${allChildren.length}: ${c.input.type} ---\n${c.plan?.scriptedPlan?.executionScript ?? "# no script"}`)
+                .join("\n\n");
             const parentDep = deployments.get(parentOp.id);
             if (parentDep && parentDep.status === "pending") {
-                parentDep.plan = { steps: combinedSteps, reasoning: combinedReasoning };
-                parentDep.rollbackPlan = { steps: [], reasoning: "Child operations handle their own rollback" };
+                parentDep.plan = {
+                    scriptedPlan: {
+                        platform: "bash",
+                        executionScript: combinedScript,
+                        dryRunScript: null,
+                        rollbackScript: null,
+                        reasoning: combinedReasoning,
+                        stepSummary: combinedStepSummary,
+                    },
+                    reasoning: combinedReasoning,
+                };
+                parentDep.rollbackPlan = {
+                    scriptedPlan: {
+                        platform: "bash",
+                        executionScript: "# Child operations handle their own rollback",
+                        dryRunScript: null,
+                        rollbackScript: null,
+                        reasoning: "Child operations handle their own rollback",
+                        stepSummary: [],
+                    },
+                    reasoning: "Child operations handle their own rollback",
+                };
                 parentDep.status = "awaiting_approval";
                 parentDep.recommendation = computeRecommendation(parentDep, deployments);
                 deployments.save(parentDep);
@@ -1654,7 +1671,7 @@ export function registerOperationRoutes(app, deployments, debrief, partitions, e
                     decisionType: "composite-plan-ready",
                     decision: `All ${allChildren.length} child plans ready — composite awaiting approval`,
                     reasoning: combinedReasoning,
-                    context: { childIds, totalSteps: combinedSteps.length },
+                    context: { childIds, totalSteps: combinedStepSummary.length },
                 });
             }
         }