@jujulego/jill 3.0.0-alpha.7 → 3.0.0-alpha.8

package/dist/inked.js

@@ -1,4 +1,4 @@
-;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="92368bb9-8978-4811-a19e-8d31de9120d2",e._sentryDebugIdIdentifier="sentry-dbid-92368bb9-8978-4811-a19e-8d31de9120d2");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.7"};}catch(e){}}();import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="709d1bbb-5a2d-41fa-b3b6-a52a755c1e53",e._sentryDebugIdIdentifier="sentry-dbid-709d1bbb-5a2d-41fa-b3b6-a52a755c1e53");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.8"};}catch(e){}}();import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { startSpan } from '@sentry/node';
 import { useStderr, render } from 'ink';
 import { inject$ } from '@kyrielle/injector';

package/dist/instrument.js

@@ -1,4 +1,4 @@
-;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c983ba1b-dae6-4864-b164-e9932653ec2b",e._sentryDebugIdIdentifier="sentry-dbid-c983ba1b-dae6-4864-b164-e9932653ec2b");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.7"};}catch(e){}}();import { init } from '@sentry/node';
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c2fd80ca-6b66-4bbf-a184-cbd02d33b725",e._sentryDebugIdIdentifier="sentry-dbid-c2fd80ca-6b66-4bbf-a184-cbd02d33b725");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.8"};}catch(e){}}();import { init } from '@sentry/node';
 
 init({
     dsn: 'https://53e6d10c16975ebd025175d9836d039b@o4508229080055808.ingest.de.sentry.io/4509876546895952',

package/dist/job-exec.ink.js

@@ -0,0 +1,606 @@
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c565de71-f9f2-474d-8656-f5f60a03995d",e._sentryDebugIdIdentifier="sentry-dbid-c565de71-f9f2-474d-8656-f5f60a03995d");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.8"};}catch(e){}}();import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { WorkloadState, isWorkloadEnded } from '@jujulego/tasks';
+import { inject$ } from '@kyrielle/injector';
+import { pipe$, map$, collect$, off$, waitFor$, filter$ } from 'kyrielle';
+import process from 'node:process';
+import { S as SCHEDULER } from './main.js';
+import { Text, Box, Static, useStdout, useInput, useStdin } from 'ink';
+import { createHash } from 'node:crypto';
+import { useState, useEffect, useMemo } from 'react';
+import Spinner from 'ink-spinner';
+import ms from 'pretty-ms';
+import isUnicodeSupported from 'is-unicode-supported';
+import { i as inked } from './inked.js';
+import '@sentry/node';
+import 'yargs/helpers';
+import 'yargs';
+import '@kyrielle/logger';
+import 'node:fs';
+import 'path-scurry';
+import '@swc/helpers/_/_apply_decs_2203_r';
+import 'node:stream/consumers';
+import 'node:path';
+import 'glob';
+import 'normalize-package-data';
+import 'semver';
+import 'moo';
+import 'node:child_process';
+import 'chalk';
+import 'slugify';
+import '@jujulego/quick-tag';
+import 'ajv';
+import 'node:os';
+import 'cosmiconfig';
+import 'chalk-template';
+
+// Hook
+function useWorkflowFlatTree(workload, verbose) {
+    const [tree, setTree] = useState(()=>buildTree(workload, verbose));
+    useEffect(()=>{
+        const oldHash = hashTree(tree);
+        let dirty = false;
+        function update() {
+            if (!dirty) return;
+            const updated = buildTree(workload, verbose);
+            if (hashTree(updated) !== oldHash) {
+                setTree(updated);
+            }
+            dirty = false;
+        }
+        const off = pipe$(tree, map$(({ workload })=>workload.state$.subscribe(()=>{
+                dirty = true;
+                queueMicrotask(update);
+            })), collect$(off$()));
+        return ()=>{
+            dirty = false;
+            off.unsubscribe();
+        };
+    }, [
+        tree,
+        verbose,
+        workload
+    ]);
+    return tree;
+}
+// Utils
+function* listRoots(workload) {
+    const marks = new Set();
+    const queue = [
+        workload
+    ];
+    while(queue.length){
+        const item = queue.shift();
+        // Mark all member of workflows, so they're not added as root
+        if (isWorkflow(item)) {
+            for (const wkl of item.workloads()){
+                marks.add(wkl.id);
+                queue.unshift(wkl);
+            }
+        }
+        // Load job dependencies
+        if (isJob(item)) {
+            for (const dep of item.dependencies()){
+                queue.push(dep);
+            }
+        }
+        // Ignore marked workloads
+        if (marks.has(item.id)) {
+            continue;
+        }
+        yield item;
+        marks.add(item.id);
+    }
+}
+function buildTree(workload, verbose = false) {
+    const tree = [];
+    const stack = pipe$(listRoots(workload), map$((workload)=>({
+            workload,
+            level: 0
+        })), collect$());
+    while(stack.length > 0){
+        const item = stack.pop();
+        const mustShow = [
+            WorkloadState.Starting,
+            WorkloadState.Running,
+            WorkloadState.Failed
+        ].includes(item.workload.state());
+        if (!verbose && !isWorkflow(item.workload) && !mustShow && item.level > 0) {
+            continue;
+        }
+        // Add to tree
+        let level = item.level;
+        if (item.workload.label !== '[hidden]') {
+            tree.push(item);
+            level++;
+        }
+        // Load "member" tasks
+        if (isWorkflow(item.workload)) {
+            const children = [
+                ...item.workload.workloads()
+            ].reverse();
+            for (const workload of children){
+                stack.push({
+                    workload,
+                    level
+                });
+            }
+        }
+    }
+    return tree;
+}
+function isJob(workload) {
+    return 'dependencies' in workload && typeof workload.dependencies === 'function';
+}
+function isWorkflow(workload) {
+    return 'workloads' in workload && typeof workload.workloads === 'function';
+}
+function hashTree(tree) {
+    const hash = createHash('sha256');
+    for (const { workload } of tree){
+        hash.update(workload.id);
+    }
+    return hash.digest('hex');
+}
+
+const isSupported = !isUnicodeSupported();
+const success = isSupported ? '✔' : '√';
+const error = isSupported ? '✖' : '×';
+
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// Component
+function WorkloadName({ workload, withWorkspace, ...rest }) {
+    if (isScriptWorkflow(workload)) {
+        return /*#__PURE__*/ jsxs(Text, {
+            ...rest,
+            children: [
+                "Run ",
+                /*#__PURE__*/ jsx(Text, {
+                    bold: true,
+                    children: workload.script
+                }),
+                " script",
+                withWorkspace && /*#__PURE__*/ jsxs(Fragment, {
+                    children: [
+                        ' ',
+                        "in ",
+                        workload.workspace.name
+                    ]
+                })
+            ]
+        });
+    }
+    let name = workload.label;
+    if (workload.type !== 'spawn') {
+        name = capitalize(name);
+    }
+    return /*#__PURE__*/ jsx(Text, {
+        ...rest,
+        children: name
+    });
+}
+// Utils
+function isScriptWorkflow(workload) {
+    return workload.type === 'script';
+}
+
+// Component
+function WorkloadSpinner({ workload }) {
+    // Track task state
+    const [state, setState] = useState(workload.state());
+    useEffect(()=>{
+        const sub = workload.state$.subscribe(setState);
+        return sub.unsubscribe;
+    }, [
+        workload.state$
+    ]);
+    // Render
+    const dim = workload.type === 'spawn';
+    const time = workload.duration().seconds() * 1000;
+    switch(state){
+        case WorkloadState.Blocked:
+        case WorkloadState.Ready:
+        case WorkloadState.Starting:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "grey",
+                        children: '\u00B7'
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            color: "grey",
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    })
+                ]
+            });
+        case WorkloadState.Running:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        dimColor: dim,
+                        children: /*#__PURE__*/ jsx(Spinner, {})
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            dimColor: dim,
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    })
+                ]
+            });
+        case WorkloadState.Canceling:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        dimColor: dim,
+                        color: "grey",
+                        children: /*#__PURE__*/ jsx(Spinner, {
+                            type: "line2"
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            dimColor: dim,
+                            color: "grey",
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    })
+                ]
+            });
+        case WorkloadState.Succeeded:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "green",
+                        children: success
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            dimColor: dim,
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsxs(Text, {
+                            color: dim ? 'grey' : 'dim',
+                            children: [
+                                "(took ",
+                                ms(time),
+                                ")"
+                            ]
+                        })
+                    })
+                ]
+            });
+        case WorkloadState.Failed:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        color: "red",
+                        children: error
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            dimColor: dim,
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsxs(Text, {
+                            color: dim ? 'grey' : 'dim',
+                            children: [
+                                "(took ",
+                                ms(time),
+                                ")"
+                            ]
+                        })
+                    })
+                ]
+            });
+        case WorkloadState.Canceled:
+            return /*#__PURE__*/ jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        dimColor: true,
+                        children: "-"
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        children: /*#__PURE__*/ jsx(WorkloadName, {
+                            dimColor: true,
+                            wrap: "truncate",
+                            workload: workload,
+                            withWorkspace: true
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        paddingLeft: 1,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsxs(Text, {
+                            color: dim ? 'grey' : 'dim',
+                            children: [
+                                "(took ",
+                                ms(time),
+                                ")"
+                            ]
+                        })
+                    })
+                ]
+            });
+    }
+}
+
+// Hook
+function useScriptsStats(workloads) {
+    const [stats, setStats] = useState(()=>countScripts(workloads));
+    useEffect(()=>{
+        let dirty = false;
+        function recount() {
+            if (!dirty) return;
+            setStats(countScripts(workloads));
+            dirty = false;
+        }
+        const off = pipe$(workloads, map$((wkl)=>wkl.state$.subscribe(()=>{
+                dirty = true;
+                queueMicrotask(recount);
+            })), collect$(off$()));
+        return ()=>{
+            dirty = false;
+            off.unsubscribe();
+        };
+    }, [
+        workloads
+    ]);
+    return stats;
+}
+// Utils
+function countScripts(workloads) {
+    const stats = {
+        [WorkloadState.Ready]: 0,
+        [WorkloadState.Blocked]: 0,
+        [WorkloadState.Starting]: 0,
+        [WorkloadState.Running]: 0,
+        [WorkloadState.Succeeded]: 0,
+        [WorkloadState.Failed]: 0,
+        [WorkloadState.Canceling]: 0,
+        [WorkloadState.Canceled]: 0
+    };
+    for (const workload of workloads){
+        if (workload.type === 'script') {
+            stats[workload.state()] += 1;
+        }
+    }
+    return stats;
+}
+
+// Component
+function WorkloadTreeStats({ tree, ...rest }) {
+    const workloads = useMemo(()=>tree.map((item)=>item.workload), [
+        tree
+    ]);
+    const stats = useScriptsStats(workloads);
+    // Render
+    const running = stats[WorkloadState.Running] + stats[WorkloadState.Starting] + stats[WorkloadState.Canceling];
+    const done = stats[WorkloadState.Succeeded];
+    const failed = stats[WorkloadState.Failed];
+    const canceled = stats[WorkloadState.Canceled];
+    return /*#__PURE__*/ jsxs(Text, {
+        ...rest,
+        children: [
+            running > 0 && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(Spinner, {
+                        type: "sand"
+                    }),
+                    " ",
+                    /*#__PURE__*/ jsx(Text, {
+                        bold: true,
+                        children: running
+                    }),
+                    " running"
+                ]
+            }),
+            running > 0 && done > 0 && ', ',
+            done > 0 && /*#__PURE__*/ jsxs(Text, {
+                color: "green",
+                children: [
+                    success,
+                    " ",
+                    done,
+                    " done"
+                ]
+            }),
+            running + done > 0 && failed > 0 && ', ',
+            failed > 0 && /*#__PURE__*/ jsxs(Text, {
+                color: "red",
+                children: [
+                    error,
+                    " ",
+                    failed,
+                    " failed"
+                ]
+            }),
+            running + done + failed > 0 && canceled > 0 && ', ',
+            canceled > 0 && /*#__PURE__*/ jsxs(Text, {
+                dimColor: true,
+                children: [
+                    "- ",
+                    canceled,
+                    " canceled"
+                ]
+            })
+        ]
+    });
+}
+
+// Component
+function WorkloadTreeCompleted({ workload, verbose }) {
+    const tree = useWorkflowFlatTree(workload, verbose);
+    // Render
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Static, {
+                items: tree,
+                children: ({ workload, level })=>/*#__PURE__*/ jsx(Box, {
+                        marginLeft: level * 2,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsx(WorkloadSpinner, {
+                            workload: workload
+                        })
+                    }, workload.id)
+            }),
+            /*#__PURE__*/ jsx(WorkloadTreeStats, {
+                tree: tree
+            })
+        ]
+    });
+}
+
+// Component
+function WorkloadTreeFullSpinner({ workload, verbose }) {
+    const tree = useWorkflowFlatTree(workload, verbose);
+    // Render
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Box, {
+                flexDirection: "column",
+                children: tree.map(({ workload, level })=>/*#__PURE__*/ jsx(Box, {
+                        marginLeft: level * 2,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsx(WorkloadSpinner, {
+                            workload: workload
+                        })
+                    }, workload.id))
+            }),
+            /*#__PURE__*/ jsx(WorkloadTreeStats, {
+                tree: tree
+            })
+        ]
+    });
+}
+
+function useStdoutDimensions() {
+    const { stdout } = useStdout();
+    const [dimensions, setDimensions] = useState({
+        columns: stdout.columns ?? Infinity,
+        rows: stdout.rows ?? Infinity
+    });
+    useEffect(()=>{
+        const handler = ()=>setDimensions({
+                columns: stdout.columns ?? Infinity,
+                rows: stdout.rows ?? Infinity
+            });
+        stdout.on('resize', handler);
+        return ()=>{
+            stdout.off('resize', handler);
+        };
+    }, [
+        stdout
+    ]);
+    return dimensions;
+}
+
+// Component
+function WorkloadTreeScrollableSpinner({ workload, verbose }) {
+    const tree = useWorkflowFlatTree(workload, verbose);
+    // Manage scroll
+    const { rows: termRows } = useStdoutDimensions();
+    const [scroll, setScroll] = useState(0);
+    const maxRows = Math.min(termRows - 4, tree.length);
+    const firstIndex = Math.max(0, tree.length - scroll - maxRows);
+    const lastIndex = Math.min(tree.length, firstIndex + maxRows);
+    const effectiveScroll = tree.length - lastIndex;
+    useInput((_, key)=>{
+        if (key.upArrow) {
+            setScroll(Math.min(tree.length - maxRows, effectiveScroll + 1));
+        } else {
+            setScroll(Math.max(0, effectiveScroll - 1));
+        }
+    });
+    // Render
+    const slice = tree.slice(firstIndex, lastIndex);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Box, {
+                flexDirection: "column",
+                children: slice.map(({ workload, level })=>/*#__PURE__*/ jsx(Box, {
+                        marginLeft: level * 2,
+                        flexShrink: 0,
+                        children: /*#__PURE__*/ jsx(WorkloadSpinner, {
+                            workload: workload
+                        })
+                    }, workload.id))
+            }),
+            /*#__PURE__*/ jsxs(Text, {
+                children: [
+                    /*#__PURE__*/ jsx(WorkloadTreeStats, {
+                        tree: tree
+                    }),
+                    termRows < tree.length && /*#__PURE__*/ jsx(Text, {
+                        color: "grey",
+                        children: " | use keyboard arrows to scroll"
+                    })
+                ]
+            })
+        ]
+    });
+}
+
+// Component
+function WorkloadTreeSpinner({ workload, verbose }) {
+    const stdin = useStdin();
+    if (stdin.isRawModeSupported) {
+        return /*#__PURE__*/ jsx(WorkloadTreeScrollableSpinner, {
+            workload: workload,
+            verbose: verbose
+        });
+    } else {
+        return /*#__PURE__*/ jsx(WorkloadTreeFullSpinner, {
+            workload: workload,
+            verbose: verbose
+        });
+    }
+}
+
+const JobExecInk = inked(async function*({ job, verbose }) {
+    const scheduler = await inject$(SCHEDULER);
+    yield /*#__PURE__*/ jsx(WorkloadTreeSpinner, {
+        workload: job,
+        verbose: verbose
+    });
+    scheduler.register(job);
+    const outcome = await waitFor$(pipe$(job.state$, filter$(isWorkloadEnded)));
+    yield /*#__PURE__*/ jsx(WorkloadTreeCompleted, {
+        workload: job,
+        verbose: verbose
+    });
+    if (outcome !== WorkloadState.Succeeded) {
+        process.exitCode = 1;
+    }
+});
+
+export { JobExecInk as default };
+//# sourceMappingURL=job-exec.ink.js.map