relay-ide 0.1.0

package/dist/server/auth.js

@@ -0,0 +1,65 @@
+import crypto from 'node:crypto';
+import { promisify } from 'node:util';
+const scrypt = promisify(crypto.scrypt);
+const SCRYPT_KEYLEN = 64;
+const MAX_ATTEMPTS = 5;
+const LOCKOUT_DURATION_MS = 15 * 60 * 1000; // 15 minutes
+const attemptMap = new Map();
+export async function hashPin(pin) {
+    const salt = crypto.randomBytes(16).toString('hex');
+    const derived = (await scrypt(pin, salt, SCRYPT_KEYLEN));
+    return `scrypt:${salt}:${derived.toString('hex')}`;
+}
+export async function verifyPin(pin, hash) {
+    if (!hash)
+        return false;
+    if (hash.startsWith('scrypt:')) {
+        const [, salt, storedHashHex] = hash.split(':');
+        if (!salt || !storedHashHex)
+            return false;
+        try {
+            const storedBuf = Buffer.from(storedHashHex, 'hex');
+            if (storedBuf.length !== SCRYPT_KEYLEN)
+                return false;
+            const derived = (await scrypt(pin, salt, SCRYPT_KEYLEN));
+            return crypto.timingSafeEqual(storedBuf, derived);
+        }
+        catch {
+            return false;
+        }
+    }
+    // Legacy bcrypt hashes are migrated at startup; if one reaches here, reject it
+    return false;
+}
+export function isRateLimited(ip) {
+    const entry = attemptMap.get(ip);
+    if (!entry)
+        return false;
+    if (entry.lockedUntil) {
+        if (Date.now() < entry.lockedUntil) {
+            return true;
+        }
+        attemptMap.delete(ip);
+    }
+    return false;
+}
+export function recordFailedAttempt(ip) {
+    const entry = attemptMap.get(ip) ?? { count: 0, lockedUntil: null };
+    entry.count += 1;
+    if (entry.count >= MAX_ATTEMPTS) {
+        entry.lockedUntil = Date.now() + LOCKOUT_DURATION_MS;
+    }
+    attemptMap.set(ip, entry);
+}
+export function clearRateLimit(ip) {
+    attemptMap.delete(ip);
+}
+export function generateCookieToken() {
+    return crypto.randomBytes(32).toString('hex');
+}
+export function isLegacyHash(hash) {
+    return !!hash && !hash.startsWith('scrypt:');
+}
+export function _resetForTesting() {
+    attemptMap.clear();
+}

package/dist/server/belayer/executor.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as sessions from '../sessions.js';
+import { transitionPipeline, updatePipeline, getPipeline } from './pipeline.js';
+import { buildBrainstormPrompt, buildPlanPrompt, buildExecutionPrompt, buildReviewPrompt, buildStuckPrompt } from './prompts.js';
+export function buildClaudeArgs(model) {
+    return ['-p', '--dangerously-skip-permissions', '--model', model];
+}
+export function parseVerdictFile(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed.goalName !== 'string' ||
+            typeof parsed.pass !== 'boolean' ||
+            !Array.isArray(parsed.criteriaResults) ||
+            typeof parsed.summary !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+let eventCallback = null;
+export function onPipelineEvent(cb) {
+    eventCallback = cb;
+}
+function emitEvent(pipelineId, event, data) {
+    if (eventCallback)
+        eventCallback(pipelineId, event, data);
+}
+export async function startPipeline(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    // Move from intake to brainstorming
+    transitionPipeline(pipelineId, 'brainstorming');
+    emitEvent(pipelineId, 'pipeline-state-changed', { state: 'brainstorming' });
+    const prompt = buildBrainstormPrompt(pipeline.task);
+    await runAgentPhase(pipelineId, prompt, pipeline.config.models.brainstorm, pipeline.config.targetRepo, (output) => {
+        // Store brainstorm output as PRD
+        updatePipeline(pipelineId, { prdContent: output });
+        transitionPipeline(pipelineId, 'prd_review');
+        emitEvent(pipelineId, 'pipeline-state-changed', { state: 'prd_review' });
+    });
+}
+export async function approvePrd(pipelineId, editedContent) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    if (pipeline.state !== 'prd_review')
+        throw new Error('Pipeline not in prd_review state');
+    if (editedContent) {
+        updatePipeline(pipelineId, { prdContent: editedContent });
+    }
+    transitionPipeline(pipelineId, 'planning');
+    emitEvent(pipelineId, 'pipeline-state-changed', { state: 'planning' });
+    const updatedPipeline = getPipeline(pipelineId);
+    const prompt = buildPlanPrompt(updatedPipeline.task, updatedPipeline.prdContent || '');
+    await runAgentPhase(pipelineId, prompt, updatedPipeline.config.models.brainstorm, updatedPipeline.config.targetRepo, (output) => {
+        updatePipeline(pipelineId, { planContent: output });
+        transitionPipeline(pipelineId, 'plan_review');
+        emitEvent(pipelineId, 'pipeline-state-changed', { state: 'plan_review' });
+    });
+}
+export async function approvePlan(pipelineId, editedContent) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    if (pipeline.state !== 'plan_review')
+        throw new Error('Pipeline not in plan_review state');
+    if (editedContent) {
+        updatePipeline(pipelineId, { planContent: editedContent });
+    }
+    await startExecution(pipelineId);
+}
+export async function startExecution(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    if (pipeline.state !== 'executing') {
+        transitionPipeline(pipelineId, 'executing');
+        emitEvent(pipelineId, 'pipeline-state-changed', { state: 'executing' });
+    }
+    const failedVerdicts = pipeline.verdicts.filter((v) => !v.pass);
+    const prompt = buildExecutionPrompt(pipeline.task, pipeline.planContent || '', failedVerdicts.length > 0 ? failedVerdicts : undefined);
+    // TODO: Create git worktree for execution if not already created
+    const cwd = pipeline.worktreePath || pipeline.config.targetRepo;
+    await runAgentPhase(pipelineId, prompt, pipeline.config.models.execute, cwd, () => {
+        startReview(pipelineId);
+    });
+}
+export async function startReview(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    transitionPipeline(pipelineId, 'reviewing');
+    emitEvent(pipelineId, 'pipeline-state-changed', { state: 'reviewing' });
+    const cwd = pipeline.worktreePath || pipeline.config.targetRepo;
+    const prompt = buildReviewPrompt(pipeline.task, cwd);
+    await runAgentPhase(pipelineId, prompt, pipeline.config.models.review, cwd, () => {
+        // Try to read verdict file
+        const verdictPath = path.join(cwd, '.belayer', 'verdict.json');
+        let verdict = null;
+        try {
+            const content = fs.readFileSync(verdictPath, 'utf8');
+            verdict = parseVerdictFile(content);
+        }
+        catch {
+            // No verdict file
+        }
+        if (verdict) {
+            const updatedPipeline = getPipeline(pipelineId);
+            const verdicts = [...updatedPipeline.verdicts, verdict];
+            updatePipeline(pipelineId, { verdicts });
+            emitEvent(pipelineId, 'pipeline-verdict', { verdict: verdict });
+            if (verdict.pass) {
+                transitionPipeline(pipelineId, 'pr_created');
+                emitEvent(pipelineId, 'pipeline-state-changed', { state: 'pr_created' });
+                // TODO: create PR
+            }
+            else if (updatedPipeline.attempts >= updatedPipeline.maxAttempts) {
+                const stuckReport = buildStuckPrompt(updatedPipeline.task, verdicts, updatedPipeline.attempts);
+                updatePipeline(pipelineId, { stuckReport });
+                transitionPipeline(pipelineId, 'stuck');
+                emitEvent(pipelineId, 'pipeline-state-changed', { state: 'stuck' });
+            }
+            else {
+                transitionPipeline(pipelineId, 'retry');
+                emitEvent(pipelineId, 'pipeline-state-changed', { state: 'retry' });
+                // Re-execute with feedback
+                startExecution(pipelineId);
+            }
+        }
+        else {
+            // No verdict — treat as failure
+            transitionPipeline(pipelineId, 'failed');
+            updatePipeline(pipelineId, { error: 'Review did not produce a verdict.json file' });
+            emitEvent(pipelineId, 'pipeline-state-changed', { state: 'failed' });
+        }
+    });
+}
+export async function resumeFromStuck(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    if (pipeline.state !== 'stuck')
+        throw new Error('Pipeline not in stuck state');
+    transitionPipeline(pipelineId, 'executing');
+    emitEvent(pipelineId, 'pipeline-state-changed', { state: 'executing' });
+    await startExecution(pipelineId);
+}
+export function abortPipeline(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    if (pipeline.state === 'done' || pipeline.state === 'failed') {
+        throw new Error('Pipeline is already ' + pipeline.state);
+    }
+    // Kill active session if any
+    if (pipeline.activeSessionId) {
+        try {
+            sessions.kill(pipeline.activeSessionId);
+        }
+        catch {
+            // Session may already be gone
+        }
+        updatePipeline(pipelineId, { activeSessionId: undefined });
+    }
+    transitionPipeline(pipelineId, 'failed');
+    updatePipeline(pipelineId, { error: 'Aborted by user' });
+    emitEvent(pipelineId, 'pipeline-state-changed', { state: 'failed' });
+}
+async function runAgentPhase(pipelineId, prompt, model, cwd, onComplete) {
+    const args = [...buildClaudeArgs(model), prompt];
+    let output = '';
+    const session = sessions.create({
+        type: 'repo',
+        repoPath: cwd,
+        cwd,
+        command: 'claude',
+        args,
+        displayName: `belayer-${pipelineId.slice(0, 8)}`,
+    });
+    updatePipeline(pipelineId, { activeSessionId: session.id });
+    // Monitor for completion via PTY exit
+    const ptySession = sessions.get(session.id);
+    if (ptySession) {
+        // Collect output
+        const dataDisposable = ptySession.pty.onData((data) => {
+            output += data;
+            emitEvent(pipelineId, 'pipeline-output', { chunk: data });
+        });
+        ptySession.pty.onExit(() => {
+            dataDisposable.dispose();
+            updatePipeline(pipelineId, { activeSessionId: undefined });
+            onComplete(output);
+        });
+    }
+}

package/dist/server/belayer/intake.js

@@ -0,0 +1,27 @@
+export class TextSource {
+    name = 'text';
+    canHandle(input) {
+        return input.trim().length > 0;
+    }
+    async fetch(input) {
+        const lines = input.trim().split('\n').map((l) => l.trim());
+        const title = lines[0] || '';
+        const description = lines.length > 1 ? lines.slice(1).join('\n') : title;
+        return {
+            source: 'text',
+            title,
+            description,
+        };
+    }
+}
+const sources = [new TextSource()];
+export function resolveTaskSource(input) {
+    if (!input.trim()) {
+        throw new Error('No task source can handle empty input');
+    }
+    for (const source of sources) {
+        if (source.canHandle(input))
+            return source;
+    }
+    throw new Error('No task source can handle this input');
+}

package/dist/server/belayer/pipeline.js

@@ -0,0 +1,97 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { VALID_TRANSITIONS } from './types.js';
+const pipelines = new Map();
+let pipelinesDir = path.join(os.homedir(), '.config', 'claude-remote-cli', 'pipelines');
+export function setPipelinesDir(dir) {
+    pipelinesDir = dir;
+}
+function ensureDir() {
+    if (!fs.existsSync(pipelinesDir)) {
+        fs.mkdirSync(pipelinesDir, { recursive: true });
+    }
+}
+function persist(pipeline) {
+    ensureDir();
+    const filePath = path.join(pipelinesDir, pipeline.id + '.json');
+    fs.writeFileSync(filePath, JSON.stringify(pipeline, null, 2), 'utf8');
+}
+export function createPipeline(task, config) {
+    const now = new Date().toISOString();
+    const pipeline = {
+        id: crypto.randomBytes(8).toString('hex'),
+        state: 'intake',
+        task,
+        config,
+        createdAt: now,
+        updatedAt: now,
+        attempts: 0,
+        maxAttempts: config.maxAttempts,
+        verdicts: [],
+    };
+    pipelines.set(pipeline.id, pipeline);
+    persist(pipeline);
+    return pipeline;
+}
+export function getPipeline(id) {
+    return pipelines.get(id) ?? null;
+}
+export function listPipelines() {
+    return Array.from(pipelines.values()).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+export function transitionPipeline(id, newState) {
+    const pipeline = pipelines.get(id);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + id);
+    const allowed = VALID_TRANSITIONS[pipeline.state];
+    if (!allowed || !allowed.includes(newState)) {
+        throw new Error(`Invalid transition from ${pipeline.state} to ${newState}`);
+    }
+    pipeline.state = newState;
+    pipeline.updatedAt = new Date().toISOString();
+    if (newState === 'retry') {
+        pipeline.attempts += 1;
+    }
+    pipelines.set(id, pipeline);
+    persist(pipeline);
+    return pipeline;
+}
+export function updatePipeline(id, updates) {
+    const pipeline = pipelines.get(id);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + id);
+    Object.assign(pipeline, updates);
+    pipeline.updatedAt = new Date().toISOString();
+    pipelines.set(id, pipeline);
+    persist(pipeline);
+    return pipeline;
+}
+export function deletePipeline(id) {
+    pipelines.delete(id);
+    const filePath = path.join(pipelinesDir, id + '.json');
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // File may not exist
+    }
+}
+export function clearPipelines() {
+    pipelines.clear();
+}
+export function loadAllPipelines() {
+    ensureDir();
+    const files = fs.readdirSync(pipelinesDir).filter((f) => f.endsWith('.json'));
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(pipelinesDir, file), 'utf8');
+            const pipeline = JSON.parse(raw);
+            pipelines.set(pipeline.id, pipeline);
+        }
+        catch {
+            // Skip malformed files
+        }
+    }
+}

package/dist/server/belayer/pr-lifecycle.js

@@ -0,0 +1,69 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { updatePipeline, getPipeline } from './pipeline.js';
+const execFileAsync = promisify(execFile);
+export function buildPrTitle(task) {
+    return `feat: ${task.title}`;
+}
+export function buildPrBody(task, prdContent, attempts) {
+    return `## ${task.title}
+
+${task.description}
+
+**Automated by Belayer** — completed in ${attempts} attempt${attempts !== 1 ? 's' : ''}.
+
+<details>
+<summary>PRD</summary>
+
+${prdContent}
+
+</details>
+`;
+}
+export async function createPullRequest(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline)
+        throw new Error('Pipeline not found: ' + pipelineId);
+    const cwd = pipeline.worktreePath || pipeline.config.targetRepo;
+    const title = buildPrTitle(pipeline.task);
+    const body = buildPrBody(pipeline.task, pipeline.prdContent || '', pipeline.attempts);
+    // Push branch
+    if (pipeline.config.autoPush && pipeline.branchName) {
+        await execFileAsync('git', ['push', '-u', 'origin', pipeline.branchName], { cwd });
+    }
+    // Create PR via gh CLI
+    const { stdout } = await execFileAsync('gh', [
+        'pr', 'create',
+        '--title', title,
+        '--body', body,
+        '--base', pipeline.config.baseBranch,
+        '--json', 'number,url',
+    ], { cwd });
+    const parsed = JSON.parse(stdout);
+    const result = { prNumber: parsed.number, prUrl: parsed.url };
+    updatePipeline(pipelineId, result);
+    return result;
+}
+export async function checkCiStatus(pipelineId) {
+    const pipeline = getPipeline(pipelineId);
+    if (!pipeline || !pipeline.prNumber)
+        throw new Error('Pipeline has no PR');
+    const cwd = pipeline.worktreePath || pipeline.config.targetRepo;
+    try {
+        const { stdout } = await execFileAsync('gh', [
+            'pr', 'checks', String(pipeline.prNumber),
+            '--json', 'name,bucket',
+        ], { cwd });
+        const checks = JSON.parse(stdout);
+        if (checks.length === 0)
+            return 'success'; // No CI configured
+        if (checks.every((c) => c.bucket === 'pass'))
+            return 'success';
+        if (checks.some((c) => c.bucket === 'fail'))
+            return 'failure';
+        return 'pending';
+    }
+    catch {
+        return 'pending';
+    }
+}

package/dist/server/belayer/prompts.js

@@ -0,0 +1,154 @@
+export function buildBrainstormPrompt(task) {
+    let prompt = `You are a product engineer. Your goal is to brainstorm a design for the following task and produce a PRD (Product Requirements Document).
+
+## Task
+
+**Title:** ${task.title}
+
+**Description:**
+${task.description}
+`;
+    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+        prompt += `\n**Acceptance Criteria:**\n${task.acceptanceCriteria.map((c) => '- ' + c).join('\n')}\n`;
+    }
+    prompt += `
+## Instructions
+
+1. Analyze the task requirements
+2. Brainstorm the design approach — consider trade-offs, alternatives, and edge cases
+3. Produce a PRD with:
+   - **Goal** (one sentence)
+   - **Background** (context and motivation)
+   - **Requirements** (numbered list of specific requirements)
+   - **Acceptance Criteria** (testable criteria for each requirement)
+   - **Technical Approach** (high-level architecture decisions)
+   - **Non-Goals** (what this does NOT include)
+
+Output the PRD as a markdown document.`;
+    return prompt;
+}
+export function buildPlanPrompt(task, prdContent) {
+    return `You are a senior engineer creating an implementation plan. You have a PRD to implement.
+
+## Task
+
+**Title:** ${task.title}
+
+## PRD
+
+${prdContent}
+
+## Instructions
+
+Create a detailed implementation plan with bite-sized tasks. For each task:
+1. List exact files to create or modify
+2. Describe the changes in detail
+3. Include test requirements
+4. Keep each task small enough to complete in one commit
+
+Use the \`/harness:plan\` format: numbered tasks with file paths, step-by-step instructions, and commit messages.
+
+Output the plan as a markdown document.`;
+}
+export function buildExecutionPrompt(task, planContent, previousVerdicts) {
+    let prompt = `You are implementing a feature according to a plan. Follow the plan exactly, task by task. Use TDD where applicable. Commit after each task.
+
+## Task
+
+**Title:** ${task.title}
+
+## Plan
+
+${planContent}
+`;
+    if (previousVerdicts && previousVerdicts.length > 0) {
+        prompt += `\n## PREVIOUS REVIEW FEEDBACK\n\nThe following review(s) found issues that must be fixed:\n\n`;
+        for (const verdict of previousVerdicts) {
+            prompt += `### Review: ${verdict.goalName}\n`;
+            prompt += `**Result:** ${verdict.pass ? 'PASS' : 'FAIL'}\n`;
+            prompt += `**Summary:** ${verdict.summary}\n`;
+            for (const cr of verdict.criteriaResults) {
+                if (!cr.met) {
+                    prompt += `- **FAILED:** ${cr.criterion}${cr.reason ? ' — ' + cr.reason : ''}\n`;
+                }
+            }
+            if (verdict.suggestions && verdict.suggestions.length > 0) {
+                prompt += `**Suggestions:** ${verdict.suggestions.join('; ')}\n`;
+            }
+            prompt += '\n';
+        }
+        prompt += `Fix ALL failed criteria before marking the work as complete.\n`;
+    }
+    prompt += `\n## Completion
+
+When all tasks are done:
+1. Run all tests and ensure they pass
+2. Create a file \`.belayer/COMPLETE\` containing "done"
+`;
+    return prompt;
+}
+export function buildReviewPrompt(task, worktreePath) {
+    let prompt = `You are an independent code reviewer. Review the implementation in this worktree against the task requirements.
+
+## Task
+
+**Title:** ${task.title}
+**Description:** ${task.description}
+`;
+    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+        prompt += `\n**Acceptance Criteria:**\n${task.acceptanceCriteria.map((c) => '- ' + c).join('\n')}\n`;
+    }
+    prompt += `
+## Instructions
+
+1. Read the code changes (check git diff against the base branch)
+2. Run the tests
+3. Evaluate each acceptance criterion
+4. Write a structured verdict
+
+## Output
+
+Write the verdict to \`.belayer/verdict.json\` with this exact shape:
+
+\`\`\`json
+{
+  "goalName": "${task.title}",
+  "pass": true or false,
+  "criteriaResults": [
+    { "criterion": "description", "met": true or false, "reason": "explanation" }
+  ],
+  "summary": "overall assessment",
+  "suggestions": ["optional improvement suggestions"],
+  "timestamp": "ISO 8601 timestamp"
+}
+\`\`\`
+
+Be thorough but fair. Only fail criteria that are clearly not met.`;
+    return prompt;
+}
+export function buildStuckPrompt(task, verdicts, attempts) {
+    let prompt = `## STUCK REPORT
+
+The pipeline for "${task.title}" is stuck after ${attempts} failed attempt(s).
+
+## Verdict History
+
+`;
+    for (let i = 0; i < verdicts.length; i++) {
+        const v = verdicts[i];
+        prompt += `### Attempt ${i + 1}: ${v.pass ? 'PASS' : 'FAIL'}\n`;
+        prompt += `${v.summary}\n`;
+        for (const cr of v.criteriaResults) {
+            prompt += `- ${cr.met ? '\u2713' : '\u2717'} ${cr.criterion}${cr.reason ? ': ' + cr.reason : ''}\n`;
+        }
+        prompt += '\n';
+    }
+    prompt += `## Action Required
+
+A human must review and decide:
+1. **Fix and resume** — address the issues manually, then resume the pipeline
+2. **Skip review** — force the pipeline to proceed to PR creation
+3. **Abort** — cancel this pipeline
+`;
+    return prompt;
+}

package/dist/server/belayer/types.js

@@ -0,0 +1,23 @@
+export const DEFAULT_PIPELINE_CONFIG = {
+    models: { brainstorm: 'opus', execute: 'opus', review: 'sonnet' },
+    maxAttempts: 3,
+    autoPush: true,
+    targetRepo: '',
+    baseBranch: 'main',
+};
+export const VALID_TRANSITIONS = {
+    intake: ['brainstorming', 'failed'],
+    brainstorming: ['prd_review', 'failed'],
+    prd_review: ['planning', 'brainstorming', 'failed'],
+    planning: ['plan_review', 'failed'],
+    plan_review: ['executing', 'planning', 'failed'],
+    executing: ['reviewing', 'failed'],
+    reviewing: ['pr_created', 'retry', 'stuck', 'failed'],
+    retry: ['executing', 'stuck', 'failed'],
+    stuck: ['executing', 'failed'],
+    pr_created: ['ci_monitoring', 'done', 'failed'],
+    ci_monitoring: ['ready_for_review', 'failed'],
+    ready_for_review: ['done', 'failed'],
+    done: [],
+    failed: ['intake'],
+};