ae-agent-setup 0.2.0

package/client/lib/request_handlers_layer_structure.js

@@ -0,0 +1,180 @@
+function handleParentLayer(req, res) {
+    readJsonBody(req, res, ({ childLayerId, parentLayerId }) => {
+        if (!childLayerId) {
+            sendBadRequest(res, 'childLayerId is required');
+            log('parentLayer failed: missing childLayerId');
+            return;
+        }
+        if (parentLayerId !== undefined && parentLayerId !== null && typeof parentLayerId !== 'number') {
+            sendBadRequest(res, 'parentLayerId must be a number when specified');
+            log('parentLayer failed: invalid parentLayerId');
+            return;
+        }
+
+        const parentLiteral = parentLayerId === undefined || parentLayerId === null
+            ? 'null'
+            : String(parentLayerId);
+        const script = `parentLayer(${childLayerId}, ${parentLiteral})`;
+        handleBridgeMutationCall(script, res, 'parentLayer()', 'Failed to set parent layer');
+    });
+}
+
+function handlePrecompose(req, res) {
+    readJsonBody(req, res, ({ layerIds, name, moveAllAttributes }) => {
+        if (!Array.isArray(layerIds) || layerIds.length === 0 || !name || typeof name !== 'string') {
+            sendBadRequest(res, 'layerIds (non-empty array) and name (string) are required');
+            log('precompose failed: invalid layerIds or name');
+            return;
+        }
+        const allNumbers = layerIds.every((id) => typeof id === 'number');
+        if (!allNumbers) {
+            sendBadRequest(res, 'layerIds must be an array of numbers');
+            log('precompose failed: invalid layerIds values');
+            return;
+        }
+        if (moveAllAttributes !== undefined && typeof moveAllAttributes !== 'boolean') {
+            sendBadRequest(res, 'moveAllAttributes must be boolean when specified');
+            log('precompose failed: invalid moveAllAttributes');
+            return;
+        }
+
+        const layerIdsLiteral = toExtendScriptStringLiteral(JSON.stringify(layerIds));
+        const nameLiteral = toExtendScriptStringLiteral(name);
+        const moveLiteral = moveAllAttributes === undefined ? 'false' : String(moveAllAttributes);
+        const script = `precomposeLayers(${layerIdsLiteral}, ${nameLiteral}, ${moveLiteral})`;
+        handleBridgeMutationCall(script, res, 'precomposeLayers()', 'Failed to precompose layers');
+    });
+}
+
+function handleDuplicateLayer(req, res) {
+    readJsonBody(req, res, ({ layerId }) => {
+        if (!layerId) {
+            sendBadRequest(res, 'layerId is required');
+            log('duplicateLayer failed: missing layerId');
+            return;
+        }
+        const script = `duplicateLayer(${layerId})`;
+        handleBridgeMutationCall(script, res, 'duplicateLayer()', 'Failed to duplicate layer');
+    });
+}
+
+function handleMoveLayerOrder(req, res) {
+    readJsonBody(req, res, ({ layerId, beforeLayerId, afterLayerId, toTop, toBottom }) => {
+        if (!layerId) {
+            sendBadRequest(res, 'layerId is required');
+            log('moveLayerOrder failed: missing layerId');
+            return;
+        }
+
+        let specified = 0;
+        if (beforeLayerId !== undefined) specified += 1;
+        if (afterLayerId !== undefined) specified += 1;
+        if (toTop === true) specified += 1;
+        if (toBottom === true) specified += 1;
+        if (specified !== 1) {
+            sendBadRequest(res, 'Specify exactly one of beforeLayerId, afterLayerId, toTop, toBottom');
+            log('moveLayerOrder failed: invalid target selector');
+            return;
+        }
+        if (beforeLayerId !== undefined && typeof beforeLayerId !== 'number') {
+            sendBadRequest(res, 'beforeLayerId must be a number');
+            log('moveLayerOrder failed: invalid beforeLayerId');
+            return;
+        }
+        if (afterLayerId !== undefined && typeof afterLayerId !== 'number') {
+            sendBadRequest(res, 'afterLayerId must be a number');
+            log('moveLayerOrder failed: invalid afterLayerId');
+            return;
+        }
+        if (toTop !== undefined && typeof toTop !== 'boolean') {
+            sendBadRequest(res, 'toTop must be boolean when specified');
+            log('moveLayerOrder failed: invalid toTop');
+            return;
+        }
+        if (toBottom !== undefined && typeof toBottom !== 'boolean') {
+            sendBadRequest(res, 'toBottom must be boolean when specified');
+            log('moveLayerOrder failed: invalid toBottom');
+            return;
+        }
+
+        const beforeLiteral = beforeLayerId === undefined ? 'null' : String(beforeLayerId);
+        const afterLiteral = afterLayerId === undefined ? 'null' : String(afterLayerId);
+        const topLiteral = toTop === true ? 'true' : 'false';
+        const bottomLiteral = toBottom === true ? 'true' : 'false';
+        const script = `moveLayerOrder(${layerId}, ${beforeLiteral}, ${afterLiteral}, ${topLiteral}, ${bottomLiteral})`;
+        handleBridgeMutationCall(script, res, 'moveLayerOrder()', 'Failed to move layer order');
+    });
+}
+
+function handleDeleteLayer(req, res) {
+    readJsonBody(req, res, ({ layerId }) => {
+        if (!layerId) {
+            sendBadRequest(res, 'layerId is required');
+            log('deleteLayer failed: missing layerId');
+            return;
+        }
+        if (typeof layerId !== 'number') {
+            sendBadRequest(res, 'layerId must be a number');
+            log('deleteLayer failed: invalid layerId');
+            return;
+        }
+
+        const script = `deleteLayer(${layerId})`;
+        handleBridgeMutationCall(script, res, 'deleteLayer()', 'Failed to delete layer');
+    });
+}
+
+function handleDeleteComp(req, res) {
+    readJsonBody(req, res, ({ compId, compName }) => {
+        const hasCompId = compId !== undefined;
+        const hasCompName = compName !== undefined && compName !== null && compName !== '';
+        if ((hasCompId && hasCompName) || (!hasCompId && !hasCompName)) {
+            sendBadRequest(res, 'Provide exactly one of compId or compName');
+            log('deleteComp failed: invalid selector');
+            return;
+        }
+        if (hasCompId && typeof compId !== 'number') {
+            sendBadRequest(res, 'compId must be a number');
+            log('deleteComp failed: compId must be number');
+            return;
+        }
+        if (hasCompName && typeof compName !== 'string') {
+            sendBadRequest(res, 'compName must be a string');
+            log('deleteComp failed: compName must be string');
+            return;
+        }
+
+        const compIdLiteral = hasCompId ? String(compId) : 'null';
+        const compNameLiteral = hasCompName ? toExtendScriptStringLiteral(compName) : 'null';
+        const script = `deleteComp(${compIdLiteral}, ${compNameLiteral})`;
+        handleBridgeMutationCall(script, res, 'deleteComp()', 'Failed to delete comp');
+    });
+}
+
+function routeLayerStructureRequest(pathname, method, req, res) {
+    if (pathname === '/layer-parent' && method === 'POST') {
+        handleParentLayer(req, res);
+        return true;
+    }
+    if (pathname === '/precompose' && method === 'POST') {
+        handlePrecompose(req, res);
+        return true;
+    }
+    if (pathname === '/duplicate-layer' && method === 'POST') {
+        handleDuplicateLayer(req, res);
+        return true;
+    }
+    if (pathname === '/layer-order' && method === 'POST') {
+        handleMoveLayerOrder(req, res);
+        return true;
+    }
+    if (pathname === '/delete-layer' && method === 'POST') {
+        handleDeleteLayer(req, res);
+        return true;
+    }
+    if (pathname === '/delete-comp' && method === 'POST') {
+        handleDeleteComp(req, res);
+        return true;
+    }
+    return false;
+}

package/client/lib/request_handlers_scene.js

@@ -0,0 +1,38 @@
+function handleApplyScene(req, res) {
+    readJsonBody(req, res, ({ scene, validateOnly, mode }) => {
+        if (!scene || typeof scene !== 'object' || Array.isArray(scene)) {
+            sendBadRequest(res, 'scene is required and must be an object');
+            log('applyScene failed: invalid scene');
+            return;
+        }
+        if (validateOnly !== undefined && typeof validateOnly !== 'boolean') {
+            sendBadRequest(res, 'validateOnly must be a boolean when specified');
+            log('applyScene failed: invalid validateOnly');
+            return;
+        }
+        const normalizedMode = mode === undefined ? 'merge' : String(mode);
+        if (!['merge', 'replace-managed', 'clear-all'].includes(normalizedMode)) {
+            sendBadRequest(res, 'mode must be one of: merge, replace-managed, clear-all');
+            log('applyScene failed: invalid mode');
+            return;
+        }
+
+        const sceneLiteral = toExtendScriptStringLiteral(JSON.stringify(scene));
+        const optionsLiteral = toExtendScriptStringLiteral(
+            JSON.stringify({
+                validateOnly: validateOnly === true,
+                mode: normalizedMode,
+            }),
+        );
+        const script = `applyScene(${sceneLiteral}, ${optionsLiteral})`;
+        handleBridgeMutationCall(script, res, 'applyScene()', 'Failed to apply scene');
+    });
+}
+
+function routeSceneRequest(pathname, method, req, res) {
+    if (pathname === '/scene' && method === 'POST') {
+        handleApplyScene(req, res);
+        return true;
+    }
+    return false;
+}

package/client/lib/request_handlers_shape.js

@@ -0,0 +1,288 @@
+function handleAddShapeRepeater(req, res) {
+    readJsonBody(
+        req,
+        res,
+        ({ layerId, layerName, groupIndex, name, copies, offset, position, scale, rotation, startOpacity, endOpacity }) => {
+            const selector = normalizeLayerSelector(layerId, layerName);
+            if (!selector.ok) {
+                sendBadRequest(res, selector.error);
+                log(`addShapeRepeater failed: ${selector.error}`);
+                return;
+            }
+            if (groupIndex !== undefined && (!Number.isInteger(groupIndex) || groupIndex <= 0)) {
+                sendBadRequest(res, 'groupIndex must be a positive integer when specified');
+                log('addShapeRepeater failed: invalid groupIndex');
+                return;
+            }
+            if (name !== undefined && typeof name !== 'string') {
+                sendBadRequest(res, 'name must be a string when specified');
+                log('addShapeRepeater failed: invalid name');
+                return;
+            }
+            if (copies !== undefined && (typeof copies !== 'number' || !isFinite(copies))) {
+                sendBadRequest(res, 'copies must be a finite number when specified');
+                log('addShapeRepeater failed: invalid copies');
+                return;
+            }
+            if (offset !== undefined && (typeof offset !== 'number' || !isFinite(offset))) {
+                sendBadRequest(res, 'offset must be a finite number when specified');
+                log('addShapeRepeater failed: invalid offset');
+                return;
+            }
+            if (rotation !== undefined && (typeof rotation !== 'number' || !isFinite(rotation))) {
+                sendBadRequest(res, 'rotation must be a finite number when specified');
+                log('addShapeRepeater failed: invalid rotation');
+                return;
+            }
+            if (startOpacity !== undefined && (typeof startOpacity !== 'number' || !isFinite(startOpacity))) {
+                sendBadRequest(res, 'startOpacity must be a finite number when specified');
+                log('addShapeRepeater failed: invalid startOpacity');
+                return;
+            }
+            if (endOpacity !== undefined && (typeof endOpacity !== 'number' || !isFinite(endOpacity))) {
+                sendBadRequest(res, 'endOpacity must be a finite number when specified');
+                log('addShapeRepeater failed: invalid endOpacity');
+                return;
+            }
+
+            function isVec2(value) {
+                return Array.isArray(value)
+                    && value.length === 2
+                    && value.every((part) => typeof part === 'number' && isFinite(part));
+            }
+            if (position !== undefined && !isVec2(position)) {
+                sendBadRequest(res, 'position must be an array of 2 numbers when specified');
+                log('addShapeRepeater failed: invalid position');
+                return;
+            }
+            if (scale !== undefined && !isVec2(scale)) {
+                sendBadRequest(res, 'scale must be an array of 2 numbers when specified');
+                log('addShapeRepeater failed: invalid scale');
+                return;
+            }
+
+            const options = {};
+            if (groupIndex !== undefined) options.groupIndex = groupIndex;
+            if (name !== undefined) options.name = name;
+            if (copies !== undefined) options.copies = copies;
+            if (offset !== undefined) options.offset = offset;
+            if (position !== undefined) options.position = position;
+            if (scale !== undefined) options.scale = scale;
+            if (rotation !== undefined) options.rotation = rotation;
+            if (startOpacity !== undefined) options.startOpacity = startOpacity;
+            if (endOpacity !== undefined) options.endOpacity = endOpacity;
+
+            const optionsLiteral = Object.keys(options).length === 0
+                ? 'null'
+                : toExtendScriptStringLiteral(JSON.stringify(options));
+            const script = `addShapeRepeater(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${optionsLiteral})`;
+            handleBridgeMutationCall(script, res, 'addShapeRepeater()', 'Failed to add shape repeater');
+        },
+    );
+}
+
+function handleAddLayer(req, res) {
+    readJsonBody(
+        req,
+        res,
+        ({
+            layerType,
+            name,
+            text,
+            width,
+            height,
+            color,
+            duration,
+            shapeType,
+            shapeSize,
+            shapePosition,
+            shapeFillColor,
+            shapeFillOpacity,
+            shapeStrokeColor,
+            shapeStrokeOpacity,
+            shapeStrokeWidth,
+            shapeStrokeLineCap,
+            shapeRoundness,
+        }) => {
+            if (!layerType || typeof layerType !== 'string') {
+                sendBadRequest(res, 'layerType is required and must be a string');
+                log('addLayer failed: invalid layerType');
+                return;
+            }
+
+            const normalizedType = layerType.toLowerCase();
+            if (!['text', 'null', 'solid', 'shape'].includes(normalizedType)) {
+                sendBadRequest(res, 'Unsupported layerType. Use one of: text, null, solid, shape.');
+                log(`addLayer failed: unsupported layerType "${layerType}"`);
+                return;
+            }
+            if (name !== undefined && typeof name !== 'string') {
+                sendBadRequest(res, 'name must be a string when specified');
+                log('addLayer failed: name must be string');
+                return;
+            }
+            if (text !== undefined && typeof text !== 'string') {
+                sendBadRequest(res, 'text must be a string when specified');
+                log('addLayer failed: text must be string');
+                return;
+            }
+            if (width !== undefined && typeof width !== 'number') {
+                sendBadRequest(res, 'width must be a number when specified');
+                log('addLayer failed: width must be number');
+                return;
+            }
+            if (height !== undefined && typeof height !== 'number') {
+                sendBadRequest(res, 'height must be a number when specified');
+                log('addLayer failed: height must be number');
+                return;
+            }
+            if (duration !== undefined && typeof duration !== 'number') {
+                sendBadRequest(res, 'duration must be a number when specified');
+                log('addLayer failed: duration must be number');
+                return;
+            }
+            if (color !== undefined) {
+                const validColor = Array.isArray(color)
+                    && color.length === 3
+                    && color.every((part) => typeof part === 'number');
+                if (!validColor) {
+                    sendBadRequest(res, 'color must be an array of 3 numbers when specified');
+                    log('addLayer failed: color must be [r, g, b]');
+                    return;
+                }
+            }
+            if (shapeType !== undefined && !['ellipse', 'rect'].includes(shapeType)) {
+                sendBadRequest(res, 'shapeType must be one of: ellipse, rect');
+                log('addLayer failed: invalid shapeType');
+                return;
+            }
+            if (shapeSize !== undefined) {
+                const validShapeSize = Array.isArray(shapeSize)
+                    && shapeSize.length === 2
+                    && shapeSize.every((part) => typeof part === 'number' && isFinite(part));
+                if (!validShapeSize) {
+                    sendBadRequest(res, 'shapeSize must be an array of 2 numbers when specified');
+                    log('addLayer failed: invalid shapeSize');
+                    return;
+                }
+            }
+            if (shapePosition !== undefined) {
+                const validShapePosition = Array.isArray(shapePosition)
+                    && shapePosition.length === 2
+                    && shapePosition.every((part) => typeof part === 'number' && isFinite(part));
+                if (!validShapePosition) {
+                    sendBadRequest(res, 'shapePosition must be an array of 2 numbers when specified');
+                    log('addLayer failed: invalid shapePosition');
+                    return;
+                }
+            }
+            if (shapeFillColor !== undefined) {
+                const validShapeFillColor = Array.isArray(shapeFillColor)
+                    && shapeFillColor.length === 3
+                    && shapeFillColor.every((part) => typeof part === 'number' && isFinite(part));
+                if (!validShapeFillColor) {
+                    sendBadRequest(res, 'shapeFillColor must be an array of 3 numbers when specified');
+                    log('addLayer failed: invalid shapeFillColor');
+                    return;
+                }
+            }
+            if (shapeFillOpacity !== undefined && (typeof shapeFillOpacity !== 'number' || !isFinite(shapeFillOpacity))) {
+                sendBadRequest(res, 'shapeFillOpacity must be a finite number when specified');
+                log('addLayer failed: invalid shapeFillOpacity');
+                return;
+            }
+            if (shapeStrokeColor !== undefined) {
+                const validShapeStrokeColor = Array.isArray(shapeStrokeColor)
+                    && shapeStrokeColor.length === 3
+                    && shapeStrokeColor.every((part) => typeof part === 'number' && isFinite(part));
+                if (!validShapeStrokeColor) {
+                    sendBadRequest(res, 'shapeStrokeColor must be an array of 3 numbers when specified');
+                    log('addLayer failed: invalid shapeStrokeColor');
+                    return;
+                }
+            }
+            if (
+                shapeStrokeOpacity !== undefined
+                && (typeof shapeStrokeOpacity !== 'number' || !isFinite(shapeStrokeOpacity))
+            ) {
+                sendBadRequest(res, 'shapeStrokeOpacity must be a finite number when specified');
+                log('addLayer failed: invalid shapeStrokeOpacity');
+                return;
+            }
+            if (shapeStrokeWidth !== undefined && (typeof shapeStrokeWidth !== 'number' || !isFinite(shapeStrokeWidth))) {
+                sendBadRequest(res, 'shapeStrokeWidth must be a finite number when specified');
+                log('addLayer failed: invalid shapeStrokeWidth');
+                return;
+            }
+            if (
+                shapeStrokeLineCap !== undefined
+                && !['butt', 'round', 'projecting'].includes(shapeStrokeLineCap)
+            ) {
+                sendBadRequest(res, 'shapeStrokeLineCap must be one of: butt, round, projecting');
+                log('addLayer failed: invalid shapeStrokeLineCap');
+                return;
+            }
+            if (shapeRoundness !== undefined && (typeof shapeRoundness !== 'number' || !isFinite(shapeRoundness))) {
+                sendBadRequest(res, 'shapeRoundness must be a finite number when specified');
+                log('addLayer failed: invalid shapeRoundness');
+                return;
+            }
+
+            const options = {};
+            if (name !== undefined) options.name = name;
+            if (text !== undefined) options.text = text;
+            if (width !== undefined) options.width = width;
+            if (height !== undefined) options.height = height;
+            if (color !== undefined) options.color = color;
+            if (duration !== undefined) options.duration = duration;
+            if (shapeType !== undefined) options.shapeType = shapeType;
+            if (shapeSize !== undefined) options.shapeSize = shapeSize;
+            if (shapePosition !== undefined) options.shapePosition = shapePosition;
+            if (shapeFillColor !== undefined) options.shapeFillColor = shapeFillColor;
+            if (shapeFillOpacity !== undefined) options.shapeFillOpacity = shapeFillOpacity;
+            if (shapeStrokeColor !== undefined) options.shapeStrokeColor = shapeStrokeColor;
+            if (shapeStrokeOpacity !== undefined) options.shapeStrokeOpacity = shapeStrokeOpacity;
+            if (shapeStrokeWidth !== undefined) options.shapeStrokeWidth = shapeStrokeWidth;
+            if (shapeStrokeLineCap !== undefined) options.shapeStrokeLineCap = shapeStrokeLineCap;
+            if (shapeRoundness !== undefined) options.shapeRoundness = shapeRoundness;
+
+            const layerTypeLiteral = toExtendScriptStringLiteral(normalizedType);
+            const optionsLiteral = Object.keys(options).length === 0
+                ? 'null'
+                : toExtendScriptStringLiteral(JSON.stringify(options));
+            const script = `addLayer(${layerTypeLiteral}, ${optionsLiteral})`;
+
+            log(`Calling ExtendScript: ${script}`);
+            evalHostScript(script, (result) => {
+                try {
+                    const parsedResult = parseBridgeResult(result);
+                    if (parsedResult && parsedResult.status === 'error') {
+                        sendJson(res, 500, {
+                            status: 'error',
+                            message: parsedResult.message || 'Failed to add layer',
+                        });
+                        log(`addLayer failed: ${parsedResult.message || 'Unknown error'}`);
+                        return;
+                    }
+                    sendJson(res, 200, { status: 'success', data: parsedResult });
+                    log('addLayer successful.');
+                } catch (e) {
+                    sendBridgeParseError(res, result, e);
+                    log(`addLayer failed: ${e.toString()}`);
+                }
+            });
+        },
+    );
+}
+
+function routeShapeRequest(pathname, method, req, res) {
+    if (pathname === '/shape-repeater' && method === 'POST') {
+        handleAddShapeRepeater(req, res);
+        return true;
+    }
+    if (pathname === '/layers' && method === 'POST') {
+        handleAddLayer(req, res);
+        return true;
+    }
+    return false;
+}

package/client/lib/request_handlers_timeline.js

@@ -0,0 +1,115 @@
+function handleSetInOutPoint(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, inPoint, outPoint }) => {
+        if (inPoint === undefined && outPoint === undefined) {
+            sendBadRequest(res, 'At least one of inPoint/outPoint is required');
+            log('setInOutPoint failed: missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`setInOutPoint failed: ${selector.error}`);
+            return;
+        }
+        if (inPoint !== undefined && (typeof inPoint !== 'number' || !isFinite(inPoint))) {
+            sendBadRequest(res, 'inPoint must be a finite number when specified');
+            log('setInOutPoint failed: invalid inPoint');
+            return;
+        }
+        if (outPoint !== undefined && (typeof outPoint !== 'number' || !isFinite(outPoint))) {
+            sendBadRequest(res, 'outPoint must be a finite number when specified');
+            log('setInOutPoint failed: invalid outPoint');
+            return;
+        }
+
+        const inPointLiteral = inPoint === undefined ? 'null' : String(inPoint);
+        const outPointLiteral = outPoint === undefined ? 'null' : String(outPoint);
+        const script = `setInOutPoint(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${inPointLiteral}, ${outPointLiteral})`;
+        handleBridgeMutationCall(script, res, 'setInOutPoint()', 'Failed to set in/out point');
+    });
+}
+
+function handleMoveLayerTime(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, delta }) => {
+        if (delta === undefined) {
+            sendBadRequest(res, 'delta is required');
+            log('moveLayerTime failed: missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`moveLayerTime failed: ${selector.error}`);
+            return;
+        }
+        if (typeof delta !== 'number' || !isFinite(delta)) {
+            sendBadRequest(res, 'delta must be a finite number');
+            log('moveLayerTime failed: invalid delta');
+            return;
+        }
+
+        const script = `moveLayerTime(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${delta})`;
+        handleBridgeMutationCall(script, res, 'moveLayerTime()', 'Failed to move layer time');
+    });
+}
+
+function handleSetCti(req, res) {
+    readJsonBody(req, res, ({ time }) => {
+        if (time === undefined) {
+            sendBadRequest(res, 'time is required');
+            log('setCTI failed: missing time');
+            return;
+        }
+        if (typeof time !== 'number' || !isFinite(time)) {
+            sendBadRequest(res, 'time must be a finite number');
+            log('setCTI failed: invalid time');
+            return;
+        }
+
+        const script = `setCTI(${time})`;
+        handleBridgeMutationCall(script, res, 'setCTI()', 'Failed to set CTI');
+    });
+}
+
+function handleSetWorkArea(req, res) {
+    readJsonBody(req, res, ({ start, duration }) => {
+        if (start === undefined || duration === undefined) {
+            sendBadRequest(res, 'start and duration are required');
+            log('setWorkArea failed: missing parameters');
+            return;
+        }
+        if (typeof start !== 'number' || !isFinite(start)) {
+            sendBadRequest(res, 'start must be a finite number');
+            log('setWorkArea failed: invalid start');
+            return;
+        }
+        if (typeof duration !== 'number' || !isFinite(duration)) {
+            sendBadRequest(res, 'duration must be a finite number');
+            log('setWorkArea failed: invalid duration');
+            return;
+        }
+
+        const script = `setWorkArea(${start}, ${duration})`;
+        handleBridgeMutationCall(script, res, 'setWorkArea()', 'Failed to set work area');
+    });
+}
+
+function routeTimelineRequest(pathname, method, req, res) {
+    if (pathname === '/layer-in-out' && method === 'POST') {
+        handleSetInOutPoint(req, res);
+        return true;
+    }
+    if (pathname === '/layer-time' && method === 'POST') {
+        handleMoveLayerTime(req, res);
+        return true;
+    }
+    if (pathname === '/cti' && method === 'POST') {
+        handleSetCti(req, res);
+        return true;
+    }
+    if (pathname === '/work-area' && method === 'POST') {
+        handleSetWorkArea(req, res);
+        return true;
+    }
+    return false;
+}

package/client/lib/runtime.js

@@ -0,0 +1,35 @@
+let http = null;
+let path = null;
+let nodeReady = true;
+let nodeInitError = null;
+
+try {
+    http = require('http');
+    path = require('path');
+} catch (e) {
+    nodeReady = false;
+    nodeInitError = e;
+}
+
+const csInterface = new CSInterface();
+const extensionRoot = csInterface.getSystemPath(SystemPath.EXTENSION);
+const hostScriptPath = nodeReady
+    ? escapeForExtendScript(path.join(extensionRoot, 'host', 'index.jsx'))
+    : null;
+
+function escapeForExtendScript(str) {
+    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function toExtendScriptStringLiteral(str) {
+    return JSON.stringify(str);
+}
+
+function evalHostScript(scriptSource, callback) {
+    if (!hostScriptPath) {
+        callback('{"status":"error","message":"Host script unavailable because CEP Node.js is disabled."}');
+        return;
+    }
+    const fullScript = `$.evalFile("${hostScriptPath}");${scriptSource}`;
+    csInterface.evalScript(fullScript, callback);
+}