singleton-pipeline 0.4.0-beta.13 → 0.4.0-beta.14

package/dist/packages/cli/src/theme.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+// ============================================================
+// CLI theme — semantic tokens. Change palette here.
+// ============================================================
+const accent = chalk.hex('#AF87FF');
+// -- Semantic styles ----------------------------------------
+export const style = {
+    // Informational
+    title: (text) => accent.bold(text),
+    heading: (text) => chalk.bold(text),
+    muted: (text) => chalk.hex('#676498')(text),
+    dim: (text) => chalk.gray.italic(text),
+    // Status
+    success: (text) => chalk.green(text),
+    warn: (text) => chalk.yellow(text),
+    error: (text) => chalk.red(text),
+    info: (text) => accent(text),
+    // Data accents
+    accent: (text) => accent(text),
+    id: (text) => accent.bold(text),
+    path: (text) => chalk.gray(text),
+    value: (text) => chalk.white(text),
+    code: (text) => chalk.magenta(text)
+};
+// -- Semantic markers (prefix glyphs) -----------------------
+export const mark = {
+    success: '✓',
+    error: '✕',
+    warn: '!',
+    info: '›',
+    bullet: '·'
+};
+// -- Pre-composed line helpers ------------------------------
+export const line = {
+    success: (message) => `${style.success(mark.success)} ${message}`,
+    error: (message) => `${style.error(mark.error)} ${message}`,
+    warn: (message) => `${style.warn(mark.warn)} ${message}`,
+    info: (message) => `${style.info(mark.info)} ${message}`
+};

package/dist/packages/cli/src/timeline.js

@@ -0,0 +1,238 @@
+import blessed from 'blessed';
+import { ASCII_MODE, G, S } from './shell.js';
+const FRAMES = ASCII_MODE ? ['|', '/', '-', '\\'] : ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+function stripBlessedTags(s) {
+    return String(s || '').replace(/\{[^}]+\}/g, '');
+}
+export function createPlainTimeline(stepNames, { log = console.log } = {}) {
+    const statuses = stepNames.map(() => 'pending');
+    const meta = stepNames.map(() => '');
+    function line(index, status, info = '') {
+        const label = stepNames[index] || `step ${index + 1}`;
+        const suffix = info ? ` - ${info}` : '';
+        return `[${status}] ${label}${suffix}`;
+    }
+    return {
+        log(text) { log(stripBlessedTags(text)); },
+        logMuted(text) { log(stripBlessedTags(text)); },
+        logSuccess(text) { log(stripBlessedTags(text)); },
+        logError(text) { log(stripBlessedTags(text)); },
+        logDiffLine(raw) { log(String(raw ?? '')); },
+        setRunning(i, info = '') {
+            statuses[i] = 'running';
+            meta[i] = info;
+            log(line(i, 'running', info));
+        },
+        setPaused(i, info = '') {
+            statuses[i] = 'paused';
+            meta[i] = info;
+            log(line(i, 'paused', info));
+        },
+        setDone(i, info = '') {
+            statuses[i] = 'done';
+            meta[i] = info;
+            log(line(i, 'done', info));
+        },
+        setError(i, info = '') {
+            statuses[i] = 'error';
+            meta[i] = info;
+            log(line(i, 'error', info));
+        },
+        end() { },
+    };
+}
+// widgets: { screen, logPanel, statusBox } — provided by shell when running inside the TUI.
+// If omitted, a standalone blessed screen is created.
+export function createTimeline(stepNames, widgets = null) {
+    const N = stepNames.length;
+    const statuses = stepNames.map(() => 'pending');
+    const meta = stepNames.map(() => '');
+    let runningIdx = -1;
+    let spinnerInterval = null;
+    let spinnerFrame = 0;
+    let screen;
+    let logPanel;
+    let statusBox;
+    let setLabel = null;
+    let mirror = null;
+    let ownScreen = false;
+    if (widgets) {
+        ({ screen, logPanel, statusBox, setLabel = null, mirror = null } = widgets);
+    }
+    else {
+        ownScreen = true;
+        screen = blessed.screen({ smartCSR: true, title: 'Singleton' });
+        logPanel = blessed.log({
+            top: 0, left: 0,
+            width: '100%', height: '100%-6',
+            tags: true,
+            scrollable: true,
+            alwaysScroll: true,
+            padding: { left: 2, top: 1, right: 2 }
+        });
+        const separator = blessed.line({
+            orientation: 'horizontal',
+            bottom: 5, left: 0,
+            width: '100%',
+            style: { fg: S.border }
+        });
+        statusBox = blessed.box({
+            bottom: 1, left: 0,
+            width: '100%', height: 4,
+            tags: true,
+            padding: { left: 2, right: 2 }
+        });
+        screen.append(logPanel);
+        screen.append(separator);
+        screen.append(statusBox);
+        screen.key(['C-c'], () => { screen.destroy(); process.exit(0); });
+    }
+    function dot(status, frame = 0) {
+        if (status === 'done')
+            return `{${S.success}-fg}${G.running}{/}`;
+        if (status === 'running')
+            return `{${S.text}-fg}${FRAMES[frame % FRAMES.length]}{/}`;
+        if (status === 'paused')
+            return `{${S.warning}-fg}${G.running}{/}`;
+        if (status === 'error')
+            return `{${S.error}-fg}${G.running}{/}`;
+        return `{${S.subtle}-fg}${G.pending}{/}`;
+    }
+    function shimmerName(text, frame = 0) {
+        text = text || '';
+        const peak = frame % (text.length + 6);
+        return text.split('').map((ch, i) => {
+            const dist = Math.abs(i - peak);
+            let color = S.accent;
+            if (dist === 0)
+                color = S.text;
+            else if (dist === 1)
+                color = '#EDD9FF';
+            else if (dist === 2)
+                color = '#D4B0FE';
+            return ch === ' ' ? ch : `{${color}-fg}{bold}${ch}{/}`;
+        }).join('');
+    }
+    function compactDots(frame = 0) {
+        return stepNames.map((_name, i) => dot(statuses[i], frame)).join(`  {${S.subtle}-fg}${G.dash}{/}  `);
+    }
+    function renderTimeline(frame = 0) {
+        const currentMeta = runningIdx >= 0 && meta[runningIdx]
+            ? `  {${S.muted}-fg}${meta[runningIdx]}{/}`
+            : '';
+        const isPaused = runningIdx >= 0 && statuses[runningIdx] === 'paused';
+        const activityLabel = isPaused
+            ? `{${S.warning}-fg}{bold}Paused{/}`
+            : `{bold}Running{/}`;
+        const activityIcon = isPaused
+            ? `{${S.warning}-fg}${G.running}{/}`
+            : `{${S.text}-fg}${FRAMES[frame % FRAMES.length]}{/}`;
+        const runningLabel = runningIdx >= 0
+            ? `${activityLabel}  ${activityIcon}  ${shimmerName(stepNames[runningIdx], frame)}${currentMeta}`
+            : `{bold}Running:{/} {${S.muted}-fg}idle{/}`;
+        const statusLines = [
+            '',
+            runningLabel,
+            '',
+            compactDots(frame)
+        ];
+        statusBox.setContent(statusLines.join('\n'));
+        if (setLabel) {
+            if (runningIdx < 0) {
+                setLabel('');
+            }
+            else if (runningIdx === 0) {
+                // Index 0 is always the preflight pseudo-step — it's not a "real" pipeline step,
+                // so show "preflight" rather than fold it into the X/N count.
+                const labelText = isPaused ? 'preflight - paused' : 'preflight';
+                setLabel(`{${S.text}-fg}{bold}${labelText}{/}`);
+            }
+            else {
+                // Real steps: 1..(N-1). Subtract 1 from N to exclude preflight from the total.
+                const labelText = isPaused
+                    ? `step ${runningIdx}/${N - 1} - paused`
+                    : `step ${runningIdx}/${N - 1}`;
+                setLabel(`{${S.text}-fg}{bold}${labelText}{/}`);
+            }
+        }
+        screen.render();
+    }
+    renderTimeline();
+    return {
+        log(text) { const s = `{${S.keyword}-fg}${text}{/}`; logPanel.log(s); mirror?.(s); screen.render(); },
+        logMuted(text) { const s = `{${S.muted}-fg}${text}{/}`; logPanel.log(s); mirror?.(s); screen.render(); },
+        logSuccess(text) { const s = `{${S.success}-fg}${text}{/}`; logPanel.log(s); mirror?.(s); screen.render(); },
+        logError(text) { const s = `{${S.error}-fg}${text}{/}`; logPanel.log(s); mirror?.(s); screen.render(); },
+        logDiffLine(raw) {
+            const text = String(raw ?? '');
+            const body = text.replace(/^\s+/, '');
+            // Default to S.subtle for all non-signal lines (meta git, context, untracked previews) —
+            // one consistent gray instead of two slightly different ones. Check git meta starts before
+            // +/- because +++ and --- would otherwise match the body coloring.
+            let color = S.muted;
+            if (/^(diff --git|index |--- |\+\+\+ )/.test(body))
+                color = S.muted;
+            else if (body.startsWith('@@'))
+                color = S.keyword;
+            else if (body.startsWith('+'))
+                color = S.success;
+            else if (body.startsWith('-'))
+                color = S.error;
+            const s = `{${color}-fg}${text}{/}`;
+            logPanel.log(s);
+            mirror?.(s);
+            screen.render();
+        },
+        setRunning(i, info = '') {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            runningIdx = i;
+            statuses[i] = 'running';
+            meta[i] = info;
+            renderTimeline();
+            spinnerInterval = setInterval(() => { spinnerFrame++; renderTimeline(spinnerFrame); }, 80);
+        },
+        setPaused(i, info = '') {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            runningIdx = i;
+            statuses[i] = 'paused';
+            meta[i] = info;
+            renderTimeline();
+        },
+        setDone(i, info = '') {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            statuses[i] = 'done';
+            meta[i] = info;
+            if (runningIdx === i)
+                runningIdx = -1;
+            renderTimeline();
+        },
+        setError(i, info = '') {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            statuses[i] = 'error';
+            meta[i] = info;
+            if (runningIdx === i)
+                runningIdx = -1;
+            renderTimeline();
+        },
+        end() {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            if (ownScreen)
+                screen.destroy();
+        }
+    };
+}

package/dist/packages/cli/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/cli/src/usage/aggregator.js

@@ -0,0 +1,44 @@
+export function aggregate(runs, now) {
+    const result = {
+        today: emptyBucketWithProviders(),
+        thisMonth: emptyBucketWithProviders(),
+        lastMonth: { total: 0 },
+        allTime: emptyBucketWithProviders()
+    };
+    const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const thisMonthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const lastMonthStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const buckets = [
+        { match: (d) => d >= todayStart, apply: (run) => addToBucketWithProvider(result.today, run) },
+        { match: (d) => d >= thisMonthStart, apply: (run) => addToBucketWithProvider(result.thisMonth, run) },
+        { match: (d) => d >= lastMonthStart && d <= thisMonthStart, apply: (run) => addToBucketTotalOnly(result.lastMonth, run) },
+        { match: () => true, apply: (run) => addToBucketWithProvider(result.allTime, run) },
+    ];
+    for (const run of runs) {
+        const runDate = new Date(run.createdAt);
+        for (const b of buckets) {
+            if (b.match(runDate))
+                b.apply(run);
+        }
+    }
+    return result;
+}
+function emptyBucketWithProviders() {
+    return {
+        byProvider: {
+            claude: { totalCost: 0, runCount: 0, reported: true },
+            codex: { totalCost: 0, runCount: 0, reported: false },
+            copilot: { totalCost: 0, runCount: 0, reported: true },
+            opencode: { totalCost: 0, runCount: 0, reported: true },
+        },
+        total: 0,
+    };
+}
+function addToBucketWithProvider(bucketTarget, run) {
+    bucketTarget.total += run.cost;
+    bucketTarget.byProvider[run.provider].totalCost += run.cost;
+    bucketTarget.byProvider[run.provider].runCount += 1;
+}
+function addToBucketTotalOnly(bucketTarget, run) {
+    bucketTarget.total += run.cost;
+}

package/dist/packages/cli/src/usage/reader.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+import fs from 'node:fs/promises';
+const PROVIDERS = ['claude', 'codex', 'copilot', 'opencode'];
+export async function scanRuns(rootPath) {
+    const runsPath = path.join(rootPath, '.singleton', "runs");
+    const rundDirectories = await fs.readdir(runsPath, { withFileTypes: true });
+    const runs = [];
+    for (const runDirectory of rundDirectories) {
+        if (runDirectory.isDirectory()) {
+            const runPath = path.join(runsPath, runDirectory.name);
+            const directory = await fs.readdir(runPath, { withFileTypes: true });
+            for (const file of directory) {
+                if (file.isFile() && file.name == "run-manifest.json") {
+                    const runManifestFile = path.join(runPath, file.name);
+                    const runManifest = await fs.readFile(runManifestFile, 'utf8');
+                    const runManifestJson = JSON.parse(runManifest);
+                    for (const stats of runManifestJson["stats"]) {
+                        if (!isProvider(stats.provider))
+                            continue;
+                        runs.push({ createdAt: runManifestJson.createdAt, provider: stats.provider, cost: stats.cost });
+                    }
+                }
+            }
+        }
+    }
+    return runs;
+}
+function isProvider(value) {
+    return value === 'claude' || value === 'codex' || value === 'copilot' || value === 'opencode';
+}

package/dist/packages/cli/src/usage/types.js

@@ -0,0 +1 @@
+export const BUCKET_KEYS = ["today", "this-month", "last-month", "all-time"];

package/dist/packages/server/src/index.js

@@ -0,0 +1,36 @@
+import express from 'express';
+import cors from 'cors';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WEB_DIST = path.resolve(__dirname, '../../web/dist');
+import { agentsRouter } from './routes/agents.js';
+import { pipelinesRouter } from './routes/pipelines.js';
+import { filesRouter } from './routes/files.js';
+export async function startServer({ port = 4317, root = process.cwd(), logger = console.log } = {}) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: '2mb' }));
+    const ctx = {
+        root,
+        pipelinesDir: path.join(root, '.singleton', 'pipelines'),
+        agentsCacheFile: path.join(root, '.singleton', 'agents.json')
+    };
+    app.get('/api/health', (_req, res) => res.json({ ok: true, root }));
+    app.use('/api/agents', agentsRouter(ctx));
+    app.use('/api/pipelines', pipelinesRouter(ctx));
+    app.use('/api/files', filesRouter(ctx));
+    app.use(express.static(WEB_DIST));
+    app.get('*', (_req, res) => res.sendFile(path.join(WEB_DIST, 'index.html')));
+    return new Promise((resolve) => {
+        const server = app.listen(port, () => {
+            logger(`Singleton server listening on http://localhost:${port}`);
+            logger(`Project root: ${root}`);
+            resolve(server);
+        });
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startServer({ port: Number(process.env.PORT) || 4317, root: process.cwd() });
+}

package/dist/packages/server/src/routes/agents.js

@@ -0,0 +1,31 @@
+import { Router } from 'express';
+import fs from 'node:fs/promises';
+import { scanAgents } from '../../../cli/src/scanner.js';
+export function agentsRouter(ctx) {
+    const r = Router();
+    r.get('/', async (_req, res) => {
+        try {
+            try {
+                const raw = await fs.readFile(ctx.agentsCacheFile, 'utf8');
+                return res.json(JSON.parse(raw));
+            }
+            catch {
+                const agents = await scanAgents(ctx.root);
+                return res.json({ scannedAt: new Date().toISOString(), root: ctx.root, agents });
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    r.post('/rescan', async (_req, res) => {
+        try {
+            const agents = await scanAgents(ctx.root);
+            res.json({ scannedAt: new Date().toISOString(), root: ctx.root, agents });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    return r;
+}

package/dist/packages/server/src/routes/files.js

@@ -0,0 +1,45 @@
+import { Router } from 'express';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const SKIP_DIRS = new Set(['node_modules', '.git', '.singleton', 'dist', 'build', '.next', '.cache']);
+export function toApiFilePath(relPath) {
+    return String(relPath || '').replace(/\\/g, '/');
+}
+async function walk(root, rel = '', out = []) {
+    const abs = path.join(root, rel);
+    const entries = await fs.readdir(abs, { withFileTypes: true });
+    for (const e of entries) {
+        if (e.name.startsWith('.') && e.name !== '.singleton') {
+            if (e.isDirectory())
+                continue;
+        }
+        if (e.isDirectory()) {
+            if (SKIP_DIRS.has(e.name))
+                continue;
+            await walk(root, path.join(rel, e.name), out);
+        }
+        else if (e.isFile()) {
+            out.push(toApiFilePath(path.join(rel, e.name)));
+        }
+    }
+    return out;
+}
+export function filesRouter(ctx) {
+    const r = Router();
+    r.get('/', async (req, res) => {
+        try {
+            const ext = String(req.query.ext || '').replace(/^\./, '').toLowerCase();
+            const all = await walk(ctx.root);
+            const filtered = ext
+                ? all.filter((f) => f.toLowerCase().endsWith(`.${ext}`))
+                : all;
+            filtered.sort();
+            res.json({ root: ctx.root, files: filtered });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    return r;
+}

package/dist/packages/server/src/routes/pipelines.js

@@ -0,0 +1,74 @@
+import { Router } from 'express';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function safeName(name) {
+    return String(name).replace(/[^a-zA-Z0-9_-]+/g, '-').slice(0, 80) || 'pipeline';
+}
+export function pipelinesRouter(ctx) {
+    const r = Router();
+    r.get('/', async (_req, res) => {
+        try {
+            await fs.mkdir(ctx.pipelinesDir, { recursive: true });
+            const files = (await fs.readdir(ctx.pipelinesDir)).filter((f) => f.endsWith('.json'));
+            const items = (await Promise.all(files.map(async (f) => {
+                try {
+                    const raw = await fs.readFile(path.join(ctx.pipelinesDir, f), 'utf8');
+                    const parsed = JSON.parse(raw);
+                    if (!parsed.name)
+                        return null;
+                    return { file: f, ...parsed };
+                }
+                catch {
+                    return null;
+                }
+            }))).filter(Boolean);
+            res.json({ pipelines: items });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    r.get('/:name', async (req, res) => {
+        try {
+            const file = path.join(ctx.pipelinesDir, `${safeName(req.params.name)}.json`);
+            const raw = await fs.readFile(file, 'utf8');
+            res.json(JSON.parse(raw));
+        }
+        catch (err) {
+            res.status(404).json({ error: 'not found' });
+        }
+    });
+    r.post('/', async (req, res) => {
+        try {
+            const { name, steps = [], nodes, edges } = req.body || {};
+            if (!name)
+                return res.status(400).json({ error: 'name required' });
+            await fs.mkdir(ctx.pipelinesDir, { recursive: true });
+            const safe = safeName(name);
+            const file = path.join(ctx.pipelinesDir, `${safe}.json`);
+            const payload = {
+                name: safe,
+                created: new Date().toISOString(),
+                steps,
+                nodes,
+                edges
+            };
+            await fs.writeFile(file, JSON.stringify(payload, null, 2));
+            res.json({ ok: true, file: `${safe}.json`, ...payload });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    r.delete('/:name', async (req, res) => {
+        try {
+            const file = path.join(ctx.pipelinesDir, `${safeName(req.params.name)}.json`);
+            await fs.unlink(file);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(404).json({ error: 'not found' });
+        }
+    });
+    return r;
+}

package/docs/reference.md

@@ -941,6 +941,33 @@ Start the interactive shell.
 singleton
 ```
 
+### `usage`
+
+Show cost and run usage across providers, broken down by time bucket.
+
+```bash
+singleton usage              # full summary (today, this-month, last-month, all-time)
+singleton usage today        # only today's bucket
+singleton usage this-month   # only the current month
+singleton usage last-month   # only the previous month
+singleton usage all-time     # cumulative total since the first run
+```
+
+Options:
+
+- `--root <path>` — project root, defaults to the current directory
+
+What it does:
+
+- reads every `run-manifest.json` under `.singleton/runs/`
+- aggregates cost and run count per provider, per time bucket
+- prints aligned columns with per-provider totals and bucket totals
+
+Notes:
+
+- `codex` runs report a cost of `0` because Codex usage is not surfaced in its manifest. The aggregator still counts the runs, but the cost column will read `$0`.
+- An unknown bucket name prints an error listing the valid values.
+
 ## REPL commands
 
 ```txt
@@ -951,6 +978,7 @@ singleton
 /stop
 /commit-last
 /ls
+/usage [--today | --this-month | --last-month | --all-time]
 /help
 /quit
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "singleton-pipeline",
-  "version": "0.4.0-beta.13",
+  "version": "0.4.0-beta.14",
   "description": "Visual pipeline builder for multi-agent AI workflows. Orchestrates Claude Code, Codex, Copilot, and OpenCode under a unified security policy.",
   "keywords": [
     "ai",
@@ -29,15 +29,12 @@
     "node": ">=20"
   },
   "bin": {
-    "singleton": "./packages/cli/src/index.js"
+    "singleton": "./dist/packages/cli/src/index.js"
   },
   "files": [
-    "packages/cli/src/**/*.js",
-    "!packages/cli/src/**/*.test.js",
-    "!packages/cli/src/__fixtures__",
-    "packages/cli/package.json",
-    "packages/server/src/**/*.js",
-    "packages/server/package.json",
+    "dist/packages/cli/src/**/*.js",
+    "dist/packages/cli/src/assets/**",
+    "dist/packages/server/src/**/*.js",
     "packages/web/dist/**",
     "packages/web/package.json",
     "docs/reference.md",
@@ -61,17 +58,21 @@
     "kleur": "^4.1.5"
   },
   "devDependencies": {
+    "typescript": "^6.0.3",
     "vitest": "^3.2.4"
   },
   "scripts": {
-    "singleton": "node packages/cli/src/index.js",
-    "scan": "node packages/cli/src/index.js scan",
-    "serve": "node packages/cli/src/index.js serve",
-    "dev:server": "node packages/server/src/index.js",
+    "singleton": "npm run build:ts --silent && node dist/packages/cli/src/index.js",
+    "scan": "npm run build:ts --silent && node dist/packages/cli/src/index.js scan",
+    "serve": "npm run build:ts --silent && node dist/packages/cli/src/index.js serve",
+    "dev:server": "npm run build:ts --silent && node dist/packages/server/src/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "build:ts": "tsc -p tsconfig.build.json && node -e \"require('fs').cpSync('packages/cli/src/assets', 'dist/packages/cli/src/assets', {recursive: true})\"",
+    "build": "npm run build:ts && npm run build:web",
     "build:web": "npm run build -w @singleton/web",
-    "prepublishOnly": "npm run build:web && npm test",
-    "pack:smoke": "npm pack && tar -tzf singleton-pipeline-*.tgz | head -60"
+    "prepublishOnly": "npm run build && npm test",
+    "pack:smoke": "npm run build && npm pack --cache .npm-cache && tar -tzf singleton-pipeline-*.tgz | head -60"
   }
 }