harness-async 0.1.0

package/dist/src/dashboard/routes.js

@@ -0,0 +1,107 @@
+import { Hono } from 'hono';
+import { collectRunOutput, getRunAttachCommand, syncRunState } from '../core/run-orchestrator.js';
+import { listRuns } from '../core/run-manager.js';
+import { listSchedules } from '../core/scheduler.js';
+import { getTask, getTaskEvents, getTaskGraph, listTasks } from '../core/task-manager.js';
+export function createDashboardRoutes(context) {
+    const app = new Hono();
+    app.get('/api/tasks', async (c) => {
+        const scope = parseScope(c.req.query('scope'));
+        const tasks = await listTasks({
+            cwd: context.cwd,
+            homeDir: context.homeDir,
+            scope,
+        });
+        return c.json(tasks);
+    });
+    app.get('/api/tasks/:id', async (c) => {
+        try {
+            const task = await getTask({
+                cwd: context.cwd,
+                homeDir: context.homeDir,
+                id: Number(c.req.param('id')),
+                scope: parseScope(c.req.query('scope')),
+            });
+            return c.json(task);
+        }
+        catch (error) {
+            return c.json({ message: error.message }, 404);
+        }
+    });
+    app.get('/api/tasks/:id/events', async (c) => {
+        try {
+            const events = await getTaskEvents({
+                cwd: context.cwd,
+                homeDir: context.homeDir,
+                id: Number(c.req.param('id')),
+                scope: parseScope(c.req.query('scope')),
+            });
+            return c.json(events);
+        }
+        catch (error) {
+            return c.json({ message: error.message }, 404);
+        }
+    });
+    app.get('/api/tasks/:id/runs', async (c) => {
+        try {
+            const scope = parseScope(c.req.query('scope'));
+            const runs = await listRuns({
+                cwd: context.cwd,
+                homeDir: context.homeDir,
+                scope,
+                taskId: Number(c.req.param('id')),
+            });
+            const enriched = await Promise.all(runs.map(async (run) => {
+                const current = run.status === 'running'
+                    ? await syncRunState({
+                        cwd: context.cwd,
+                        homeDir: context.homeDir,
+                    }, run.id)
+                    : run;
+                return {
+                    ...current,
+                    output: await collectRunOutput({
+                        cwd: context.cwd,
+                        homeDir: context.homeDir,
+                    }, current.id),
+                    attachCommand: current.status === 'running'
+                        ? await getRunAttachCommand({
+                            cwd: context.cwd,
+                            homeDir: context.homeDir,
+                        }, current.id)
+                        : null,
+                };
+            }));
+            return c.json(enriched);
+        }
+        catch (error) {
+            return c.json({ message: error.message }, 404);
+        }
+    });
+    app.get('/api/schedule', async (c) => {
+        const schedules = await listSchedules({
+            cwd: context.cwd,
+            homeDir: context.homeDir,
+        });
+        return c.json(schedules);
+    });
+    app.get('/api/graph', async (c) => {
+        const scope = parseScope(c.req.query('scope'));
+        const graph = await getTaskGraph({
+            cwd: context.cwd,
+            homeDir: context.homeDir,
+            scope,
+        });
+        return c.json({
+            nodes: graph.tasks,
+            edges: graph.edges,
+        });
+    });
+    return app;
+}
+function parseScope(rawScope) {
+    if (rawScope === 'global' || rawScope === 'all') {
+        return rawScope;
+    }
+    return 'project';
+}

package/dist/src/dashboard/server.js

@@ -0,0 +1,142 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { createDashboardRoutes } from './routes.js';
+import { createDashboardEventHub, toEventFiles } from './ws.js';
+import { resolveStoreDir } from '../core/store.js';
+export async function startDashboardServer(options) {
+    const app = createDashboardRoutes({
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+    });
+    const eventHub = createDashboardEventHub(toEventFiles(resolveDashboardStores(options.cwd, options.homeDir)));
+    if (options.staticDir) {
+        app.get('*', async (c, next) => {
+            const filePath = resolveStaticPath(options.staticDir ?? '', c.req.path);
+            const file = await readStaticFile(filePath, options.staticDir ?? '');
+            if (!file) {
+                return next();
+            }
+            return new Response(file.body, {
+                headers: {
+                    'content-type': file.contentType,
+                },
+            });
+        });
+    }
+    const server = createServer(async (request, response) => {
+        await handleHttpRequest(app.fetch, request, response);
+    });
+    server.on('upgrade', (request, socket, head) => {
+        const pathname = new URL(request.url ?? '/', 'http://127.0.0.1').pathname;
+        if (pathname !== '/ws') {
+            socket.destroy();
+            return;
+        }
+        eventHub.handleUpgrade(request, socket, head);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port ?? 3777, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    await eventHub.start();
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Unable to determine dashboard server port');
+    }
+    return {
+        port: address.port,
+        async stop() {
+            await eventHub.stop();
+            await closeServer(server);
+        },
+    };
+}
+function resolveDashboardStores(cwd, homeDir) {
+    return [
+        resolveStoreDir({ cwd, homeDir, scope: 'project' }),
+        resolveStoreDir({ cwd, homeDir, scope: 'global' }),
+    ];
+}
+async function handleHttpRequest(fetchHandler, request, response) {
+    const origin = `http://${request.headers.host ?? '127.0.0.1'}`;
+    const url = new URL(request.url ?? '/', origin);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                headers.append(key, entry);
+            }
+        }
+        else if (value !== undefined) {
+            headers.set(key, value);
+        }
+    }
+    const body = request.method === 'GET' || request.method === 'HEAD'
+        ? undefined
+        : request;
+    const init = {
+        method: request.method,
+        headers,
+        body,
+        duplex: 'half',
+    };
+    const honoResponse = await fetchHandler(new Request(url, init));
+    response.statusCode = honoResponse.status;
+    honoResponse.headers.forEach((value, key) => {
+        response.setHeader(key, value);
+    });
+    const payload = Buffer.from(await honoResponse.arrayBuffer());
+    response.end(payload);
+}
+async function readStaticFile(filePath, staticDir) {
+    try {
+        const targetPath = filePath.startsWith(staticDir) ? filePath : join(staticDir, 'index.html');
+        const body = await readFile(targetPath);
+        return {
+            body,
+            contentType: contentTypeFor(targetPath),
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+function resolveStaticPath(staticDir, pathname) {
+    if (pathname === '/') {
+        return join(staticDir, 'index.html');
+    }
+    return join(staticDir, pathname.replace(/^\/+/, ''));
+}
+function contentTypeFor(filePath) {
+    if (filePath.endsWith('.html')) {
+        return 'text/html; charset=utf-8';
+    }
+    if (filePath.endsWith('.js')) {
+        return 'text/javascript; charset=utf-8';
+    }
+    if (filePath.endsWith('.css')) {
+        return 'text/css; charset=utf-8';
+    }
+    if (extname(filePath) === '.json') {
+        return 'application/json; charset=utf-8';
+    }
+    return 'application/octet-stream';
+}
+async function closeServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/src/dashboard/ws.js

@@ -0,0 +1,75 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { WebSocketServer } from 'ws';
+import { eventSchema } from '../types/index.js';
+export function createDashboardEventHub(eventFiles) {
+    const sockets = new Set();
+    const watchers = chokidar.watch(eventFiles, {
+        ignoreInitial: false,
+        awaitWriteFinish: {
+            stabilityThreshold: 50,
+            pollInterval: 10,
+        },
+    });
+    const wsServer = new WebSocketServer({ noServer: true });
+    const processedLines = new Map();
+    wsServer.on('connection', (socket) => {
+        sockets.add(socket);
+        socket.on('close', () => {
+            sockets.delete(socket);
+        });
+    });
+    const processFile = async (filePath) => {
+        try {
+            const raw = await readFile(filePath, 'utf8');
+            const lines = raw.split('\n').filter(Boolean);
+            const offset = processedLines.get(filePath) ?? 0;
+            const freshLines = lines.slice(offset);
+            processedLines.set(filePath, lines.length);
+            for (const line of freshLines) {
+                broadcast(eventSchema.parse(JSON.parse(line)));
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    };
+    const broadcast = (event) => {
+        const payload = JSON.stringify(event);
+        for (const socket of sockets) {
+            if (socket.readyState === socket.OPEN) {
+                socket.send(payload);
+            }
+        }
+    };
+    return {
+        async start() {
+            watchers.on('add', (filePath) => {
+                void processFile(filePath);
+            });
+            watchers.on('change', (filePath) => {
+                void processFile(filePath);
+            });
+            await Promise.all(eventFiles.map(async (filePath) => processFile(filePath)));
+        },
+        async stop() {
+            for (const socket of sockets) {
+                socket.close();
+            }
+            await watchers.close();
+            wsServer.close();
+        },
+        broadcast,
+        handleUpgrade(request, socket, head) {
+            wsServer.handleUpgrade(request, socket, head, (client) => {
+                wsServer.emit('connection', client, request);
+            });
+        },
+    };
+}
+export function toEventFiles(storeDirs) {
+    return [...new Set(storeDirs.map((storeDir) => join(storeDir, 'events.ndjson')))];
+}

package/dist/src/types/adapter.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export const capabilitySupportSchema = z.enum([
+    'worktree',
+    'mcp',
+    'subagents',
+    'sandbox',
+]);
+export const agentToolSchema = z.enum(['claude', 'codex']);
+export const runStatusSchema = z.enum(['pending', 'running', 'completed', 'failed', 'paused']);
+export const capabilityReportSchema = z.object({
+    available: z.boolean(),
+    supports: z.array(capabilitySupportSchema),
+    version: z.string().nullable().optional(),
+});
+export const runSchema = z.object({
+    id: z.string().min(1),
+    taskId: z.number().int().positive(),
+    tool: agentToolSchema,
+    status: runStatusSchema,
+    tmuxSession: z.string().min(1),
+    startedAt: z.string().datetime({ offset: true }),
+    completedAt: z.string().datetime({ offset: true }).nullable(),
+    exitCode: z.number().int().nullable(),
+    directory: z.string().min(1),
+    scope: z.enum(['project', 'global']),
+    runDir: z.string().min(1),
+    stdoutPath: z.string().min(1),
+    exitCodePath: z.string().min(1),
+    promptPath: z.string().min(1),
+});

package/dist/src/types/index.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export { agentToolSchema, capabilityReportSchema, capabilitySupportSchema, runSchema, runStatusSchema, } from './adapter.js';
+export const taskLevelSchema = z.enum(['L1', 'L2', 'L3']);
+export const taskStatusSchema = z.enum([
+    'pending',
+    'running',
+    'blocked',
+    'waiting-review',
+    'completed',
+    'failed',
+    'paused',
+]);
+export const assigneeSchema = z.enum(['claude', 'codex', 'human', 'auto']);
+export const taskScopeSchema = z.enum(['project', 'global']);
+export const estimatedEffortSchema = z.enum(['low', 'medium', 'high']);
+export const taskSchema = z.object({
+    id: z.number().int().positive(),
+    title: z.string().min(1),
+    level: taskLevelSchema,
+    status: taskStatusSchema,
+    deps: z.array(z.number().int().positive()),
+    blocks: z.array(z.number().int().positive()),
+    assignee: assigneeSchema,
+    scope: taskScopeSchema,
+    project: z.string().nullable().optional(),
+    created: z.string().datetime({ offset: true }),
+    updated: z.string().datetime({ offset: true }),
+    tags: z.array(z.string()),
+    checkpoint: z.unknown().nullable(),
+    estimatedEffort: estimatedEffortSchema,
+    body: z.string(),
+});
+export const taskFrontmatterSchema = taskSchema.omit({ body: true });
+export const indexTaskRecordSchema = z.object({
+    level: taskLevelSchema,
+    status: taskStatusSchema,
+    deps: z.array(z.number().int().positive()),
+    file: z.string().min(1),
+    scope: taskScopeSchema,
+});
+export const dagEdgeSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    type: z.literal('depends-on').default('depends-on'),
+});
+export const indexFileSchema = z.object({
+    version: z.number().int().positive(),
+    nextId: z.number().int().positive(),
+    tasks: z.record(z.string(), indexTaskRecordSchema),
+    dag: z.object({
+        edges: z.array(dagEdgeSchema),
+    }),
+    lastUpdated: z.string().datetime({ offset: true }),
+});
+export const scheduleSchema = z.object({
+    name: z.string().min(1),
+    cron: z.string().min(1),
+    command: z.string().min(1),
+    enabled: z.boolean(),
+    lastTriggered: z.string().datetime({ offset: true }).nullable(),
+});
+export const eventTypeSchema = z.enum([
+    'task.created',
+    'task.updated',
+    'task.status_changed',
+    'run.started',
+    'run.completed',
+    'run.failed',
+    'schedule.triggered',
+    'task.dependency_unlocked',
+]);
+export const eventSchema = z.object({
+    ts: z.string().datetime({ offset: true }),
+    type: eventTypeSchema,
+    taskId: z.number().int().positive().optional(),
+    actor: z.string().min(1),
+    from: taskStatusSchema.optional(),
+    to: taskStatusSchema.optional(),
+    detail: z.record(z.string(), z.unknown()).default({}),
+});
+export const configSchema = z.object({
+    defaultAgent: assigneeSchema.exclude(['human']),
+    notify: z.object({
+        enabled: z.boolean(),
+    }),
+    dashboardPort: z.number().int().positive().default(3777),
+});

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "harness-async",
+  "version": "0.1.0",
+  "description": "Agent-first CLI for async human-agent collaboration",
+  "type": "module",
+  "bin": {
+    "ha": "dist/src/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/cli/index.ts",
+    "dev:dashboard": "vite --config src/dashboard/ui/vite.config.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json && npm run build:dashboard",
+    "build:dashboard": "vite build --config src/dashboard/ui/vite.config.ts",
+    "lint": "eslint . --ext .ts",
+    "test": "vitest run",
+    "test:e2e": "vitest run tests/e2e",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.4",
+    "@xyflow/react": "^12.8.5",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^14.0.0",
+    "dagre": "^0.8.5",
+    "gray-matter": "^4.0.3",
+    "hono": "^4.9.8",
+    "node-cron": "^4.2.1",
+    "node-notifier": "^10.0.1",
+    "proper-lockfile": "^4.1.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "ws": "^8.18.3",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.12",
+    "@types/react-dom": "^19.1.9",
+    "@types/node": "^24.5.2",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^5.0.4",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "autoprefixer": "^10.4.21",
+    "eslint": "^8.57.1",
+    "postcss": "^8.5.6",
+    "prettier": "^3.6.2",
+    "tailwindcss": "^3.4.17",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5",
+    "vitest": "^3.2.4"
+  }
+}