@exaudeus/workrail 1.5.0 → 1.5.2

package/dist/application/services/workflow-compiler.js

@@ -22,6 +22,13 @@ let WorkflowCompiler = class WorkflowCompiler {
             }
             stepById.set(step.id, step);
         }
+        for (const step of steps) {
+            const contractRef = step.outputContract?.contractRef;
+            if (contractRef && !(0, index_1.isValidContractRef)(contractRef)) {
+                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares unknown outputContract.contractRef '${contractRef}'. ` +
+                    `Known contracts: ${index_1.LOOP_CONTROL_CONTRACT_REF}`));
+            }
+        }
         const compiledLoops = new Map();
         const loopBodyStepIds = new Set();
         for (const step of steps) {
@@ -33,6 +40,11 @@ let WorkflowCompiler = class WorkflowCompiler {
                 return (0, neverthrow_1.err)(bodyResolved.error);
             for (const bodyStep of bodyResolved.value) {
                 loopBodyStepIds.add(bodyStep.id);
+                const ref = bodyStep.outputContract?.contractRef;
+                if (ref && !(0, index_1.isValidContractRef)(ref)) {
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop body step '${bodyStep.id}' in loop '${loop.id}' declares unknown outputContract.contractRef '${ref}'. ` +
+                        `Known contracts: ${index_1.LOOP_CONTROL_CONTRACT_REF}`));
+                }
             }
             const conditionSource = this.deriveConditionSource(loop, bodyResolved.value);
             compiledLoops.set(loop.id, {
@@ -56,8 +68,8 @@ let WorkflowCompiler = class WorkflowCompiler {
         if (loop.loop.conditionSource) {
             return loop.loop.conditionSource;
         }
-        const hasLoopControlContract = bodySteps.some((s) => s.outputContract?.contractRef === index_1.LOOP_CONTROL_CONTRACT_REF);
-        if (hasLoopControlContract) {
+        const loopControlStep = bodySteps.find((s) => s.outputContract?.contractRef === index_1.LOOP_CONTROL_CONTRACT_REF);
+        if (loopControlStep) {
             return {
                 kind: 'artifact_contract',
                 contractRef: index_1.LOOP_CONTROL_CONTRACT_REF,

package/dist/infrastructure/session/HttpServer.js

@@ -283,7 +283,12 @@ let HttpServer = class HttpServer {
         this.app.delete('/api/sessions/:workflow/:id', async (req, res) => {
             try {
                 const { workflow, id } = req.params;
-                await this.sessionManager.deleteSession(workflow, id);
+                const result = await this.sessionManager.deleteSession(workflow, id);
+                if (result.isErr()) {
+                    const status = result.error.code === 'SESSION_NOT_FOUND' ? 404 : 500;
+                    res.status(status).json({ success: false, error: result.error.message });
+                    return;
+                }
                 res.json({
                     success: true,
                     message: `Session ${workflow}/${id} deleted successfully`
@@ -291,7 +296,7 @@ let HttpServer = class HttpServer {
             }
             catch (error) {
                 console.error('[HttpServer] Delete session error:', error);
-                res.status(error.message?.includes('not found') ? 404 : 500).json({
+                res.status(500).json({
                     success: false,
                     error: error.message || 'Failed to delete session'
                 });

package/dist/infrastructure/session/SessionManager.d.ts

@@ -1,6 +1,14 @@
 import { EventEmitter } from 'events';
+import { type Result } from 'neverthrow';
 import { SessionDataNormalizer } from './SessionDataNormalizer';
 import { SessionDataValidator } from './SessionDataValidator';
+export type SessionManagerError = {
+    readonly code: 'SESSION_NOT_FOUND';
+    readonly message: string;
+} | {
+    readonly code: 'IO_ERROR';
+    readonly message: string;
+};
 export interface Session {
     id: string;
     workflowId: string;
@@ -30,10 +38,10 @@ export declare class SessionManager extends EventEmitter {
     private findGitRepoRoot;
     private getProjectRoot;
     getSessionPath(workflowId: string, sessionId: string): string;
-    createSession(workflowId: string, sessionId: string, initialData?: Record<string, any>): Promise<Session>;
-    updateSession(workflowId: string, sessionId: string, updates: Record<string, any>): Promise<Session>;
-    readSession(workflowId: string, sessionId: string, queryPath?: string): Promise<any>;
-    deleteSession(workflowId: string, sessionId: string): Promise<void>;
+    createSession(workflowId: string, sessionId: string, initialData?: Record<string, any>): Promise<Result<Session, SessionManagerError>>;
+    updateSession(workflowId: string, sessionId: string, updates: Record<string, any>): Promise<Result<Session, SessionManagerError>>;
+    readSession(workflowId: string, sessionId: string, queryPath?: string): Promise<Result<unknown, SessionManagerError>>;
+    deleteSession(workflowId: string, sessionId: string): Promise<Result<void, SessionManagerError>>;
     deleteSessions(sessions: Array<{
         workflowId: string;
         sessionId: string;

package/dist/infrastructure/session/SessionManager.js

@@ -24,6 +24,7 @@ const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 const events_1 = require("events");
 const tsyringe_1 = require("tsyringe");
+const neverthrow_1 = require("neverthrow");
 const tokens_js_1 = require("../../di/tokens.js");
 const SessionDataNormalizer_1 = require("./SessionDataNormalizer");
 const SessionDataValidator_1 = require("./SessionDataValidator");
@@ -76,7 +77,12 @@ let SessionManager = class SessionManager extends events_1.EventEmitter {
     }
     async createSession(workflowId, sessionId, initialData = {}) {
         const sessionPath = this.getSessionPath(workflowId, sessionId);
-        await promises_1.default.mkdir(path_1.default.dirname(sessionPath), { recursive: true });
+        try {
+            await promises_1.default.mkdir(path_1.default.dirname(sessionPath), { recursive: true });
+        }
+        catch (e) {
+            return (0, neverthrow_1.err)({ code: 'IO_ERROR', message: `Failed to create session directory: ${e instanceof Error ? e.message : String(e)}` });
+        }
         const session = {
             id: sessionId,
             workflowId,
@@ -86,15 +92,20 @@ let SessionManager = class SessionManager extends events_1.EventEmitter {
             updatedAt: new Date().toISOString(),
             data: initialData
         };
-        await this.atomicWrite(sessionPath, session);
+        try {
+            await this.atomicWrite(sessionPath, session);
+        }
+        catch (e) {
+            return (0, neverthrow_1.err)({ code: 'IO_ERROR', message: `Failed to write session: ${e instanceof Error ? e.message : String(e)}` });
+        }
         await this.updateProjectMetadata();
-        return session;
+        return (0, neverthrow_1.ok)(session);
     }
     async updateSession(workflowId, sessionId, updates) {
         const sessionPath = this.getSessionPath(workflowId, sessionId);
         const session = await this.getSession(workflowId, sessionId);
         if (!session) {
-            throw new Error(`Session not found: ${workflowId}/${sessionId}`);
+            return (0, neverthrow_1.err)({ code: 'SESSION_NOT_FOUND', message: `Session not found: ${workflowId}/${sessionId}` });
         }
         const mergedData = this.deepMerge(session.data, updates);
         const normalizedData = this.normalizer.normalize(workflowId, mergedData);
@@ -104,36 +115,40 @@ let SessionManager = class SessionManager extends events_1.EventEmitter {
         }
         session.data = normalizedData;
         session.updatedAt = new Date().toISOString();
-        await this.atomicWrite(sessionPath, session);
-        return session;
+        try {
+            await this.atomicWrite(sessionPath, session);
+        }
+        catch (e) {
+            return (0, neverthrow_1.err)({ code: 'IO_ERROR', message: `Failed to write session: ${e instanceof Error ? e.message : String(e)}` });
+        }
+        return (0, neverthrow_1.ok)(session);
     }
     async readSession(workflowId, sessionId, queryPath) {
         const session = await this.getSession(workflowId, sessionId);
         if (!session) {
-            throw new Error(`Session not found: ${workflowId}/${sessionId}`);
+            return (0, neverthrow_1.err)({ code: 'SESSION_NOT_FOUND', message: `Session not found: ${workflowId}/${sessionId}` });
         }
         if (!queryPath) {
-            return session.data;
+            return (0, neverthrow_1.ok)(session.data);
         }
-        return this.getPath(session.data, queryPath);
+        return (0, neverthrow_1.ok)(this.getPath(session.data, queryPath));
     }
     async deleteSession(workflowId, sessionId) {
         const sessionPath = this.getSessionPath(workflowId, sessionId);
         const exists = await promises_1.default.access(sessionPath).then(() => true).catch(() => false);
         if (!exists) {
-            throw new Error(`Session not found: ${workflowId}/${sessionId}`);
+            return (0, neverthrow_1.err)({ code: 'SESSION_NOT_FOUND', message: `Session not found: ${workflowId}/${sessionId}` });
         }
         this.unwatchSession(workflowId, sessionId);
         await promises_1.default.unlink(sessionPath);
         await this.updateProjectMetadata();
+        return (0, neverthrow_1.ok)(undefined);
     }
     async deleteSessions(sessions) {
         for (const { workflowId, sessionId } of sessions) {
-            try {
-                await this.deleteSession(workflowId, sessionId);
-            }
-            catch (error) {
-                console.error(`Failed to delete ${workflowId}/${sessionId}:`, error);
+            const res = await this.deleteSession(workflowId, sessionId);
+            if (res.isErr()) {
+                console.error(`Failed to delete ${workflowId}/${sessionId}:`, res.error.message);
             }
         }
     }