@haystackeditor/cli 0.15.20 → 0.15.22

package/dist/commands/verify-hosted.d.ts

@@ -0,0 +1,60 @@
+export interface HostedStartOptions {
+    base: string;
+    head: string;
+    idempotencyKey?: string;
+    account?: string;
+    wait?: boolean;
+    interval?: string;
+    timeout?: string;
+    json?: boolean;
+}
+export interface HostedStatusOptions {
+    account?: string;
+    wait?: boolean;
+    interval?: string;
+    timeout?: string;
+    json?: boolean;
+}
+interface HostedRunState {
+    runId: string;
+    status: string;
+    repository?: string;
+    baseCommit?: string;
+    headCommit?: string;
+    createdAt?: string;
+    completedAt?: string;
+    output?: Record<string, unknown>;
+    error?: string;
+}
+interface HostedPollOptions {
+    intervalMs: number;
+    timeoutMs: number;
+    onStatus?: (state: HostedRunState) => void;
+}
+interface HostedWaitResult {
+    state: HostedRunState;
+    timedOut: boolean;
+}
+export declare function parseHostedRunState(value: unknown, expectedRunId?: string): HostedRunState;
+export declare function parseHostedRepository(value: string): {
+    owner: string;
+    repository: string;
+    fullName: string;
+};
+export declare function defaultHostedIdempotencyKey(repository: string, baseCommit: string, headCommit: string): string;
+export declare function startHostedVerification(repositoryArg: string, options: HostedStartOptions, token: string): Promise<{
+    state: HostedRunState;
+    idempotencyKey: string;
+}>;
+export declare function getHostedVerification(runId: string, token: string): Promise<HostedRunState>;
+export declare function waitForHostedVerification(runId: string, token: string, options: HostedPollOptions): Promise<HostedWaitResult>;
+export declare function buildHostedJson(operation: 'start' | 'status', state: HostedRunState, extras?: {
+    account?: string;
+    idempotencyKey?: string;
+    nextCommand?: string;
+    timedOut?: boolean;
+}): Record<string, unknown>;
+export declare function hostedResumeCommand(runId: string, account?: string): string;
+export declare function verifyHostedStartCommand(repositoryArg: string, options: HostedStartOptions): Promise<void>;
+export declare function verifyHostedStatusCommand(runId: string, options: HostedStatusOptions): Promise<void>;
+export {};

package/dist/commands/verify-hosted.js

@@ -0,0 +1,342 @@
+import { createHash } from 'node:crypto';
+import chalk from 'chalk';
+import { withSchema } from '../schema.js';
+import { resolveAuthContext } from '../utils/auth.js';
+import { HaystackApiError, haystackJson } from '../utils/haystack-api.js';
+const REPOSITORY_COMPONENT = /^[A-Za-z0-9_.-]{1,100}$/;
+const COMMIT_SHA = /^[0-9a-f]{40}$/;
+const IDEMPOTENCY_KEY = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+const RUN_ID = /^cv_[0-9a-f]{48}$/;
+const STATUS = /^[a-z][a-z0-9_-]{1,31}$/;
+const TERMINAL_STATUSES = new Set(['complete', 'errored', 'expired', 'terminated']);
+const DEFAULT_INTERVAL_SECONDS = 5;
+const DEFAULT_TIMEOUT_MINUTES = 35;
+function requireRecord(value, context) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${context} returned an invalid response object.`);
+    }
+    return value;
+}
+function requireString(value, field, pattern) {
+    const candidate = value[field];
+    if (typeof candidate !== 'string'
+        || candidate.length === 0
+        || (pattern && !pattern.test(candidate))) {
+        throw new Error(`Hosted verifier response is missing a valid ${field}.`);
+    }
+    return candidate;
+}
+function optionalString(value, field) {
+    const candidate = value[field];
+    if (candidate === undefined)
+        return undefined;
+    if (typeof candidate !== 'string' || candidate.length === 0) {
+        throw new Error(`Hosted verifier response has an invalid ${field}.`);
+    }
+    return candidate;
+}
+function optionalTimestamp(value, field) {
+    const candidate = optionalString(value, field);
+    if (candidate === undefined)
+        return undefined;
+    const parsed = new Date(candidate);
+    if (!Number.isFinite(parsed.getTime())
+        || parsed.toISOString() !== candidate) {
+        throw new Error(`Hosted verifier response has an invalid ${field}.`);
+    }
+    return candidate;
+}
+export function parseHostedRunState(value, expectedRunId) {
+    const response = requireRecord(value, 'Hosted verifier');
+    const runId = requireString(response, 'runId', RUN_ID);
+    if (expectedRunId && runId !== expectedRunId) {
+        throw new Error(`Hosted verifier returned run ${runId} while status for ${expectedRunId} was requested.`);
+    }
+    const status = requireString(response, 'status', STATUS);
+    const repository = optionalString(response, 'repository');
+    if (repository) {
+        const parts = repository.split('/');
+        if (parts.length !== 2
+            || !parts.every(part => REPOSITORY_COMPONENT.test(part))) {
+            throw new Error('Hosted verifier response has an invalid repository.');
+        }
+    }
+    const baseCommit = optionalString(response, 'baseCommit');
+    const headCommit = optionalString(response, 'headCommit');
+    if (baseCommit && !COMMIT_SHA.test(baseCommit)) {
+        throw new Error('Hosted verifier response has an invalid baseCommit.');
+    }
+    if (headCommit && !COMMIT_SHA.test(headCommit)) {
+        throw new Error('Hosted verifier response has an invalid headCommit.');
+    }
+    const outputValue = response.output;
+    const output = outputValue === undefined
+        ? undefined
+        : requireRecord(outputValue, 'Hosted verifier output');
+    const createdAt = optionalTimestamp(response, 'createdAt');
+    const completedAt = optionalTimestamp(response, 'completedAt');
+    if (status === 'complete') {
+        if (!repository
+            || !baseCommit
+            || !headCommit
+            || !createdAt
+            || !completedAt
+            || !output
+            || output.runId !== runId
+            || output.repository !== repository
+            || output.baseCommit !== baseCommit
+            || output.headCommit !== headCommit
+            || output.sourceOfflineReady !== true
+            || output.sandboxDeleted !== true) {
+            throw new Error('Hosted verifier returned a complete run without a matching terminal receipt.');
+        }
+    }
+    return {
+        runId,
+        status,
+        repository,
+        baseCommit,
+        headCommit,
+        createdAt,
+        completedAt,
+        output,
+        error: optionalString(response, 'error'),
+    };
+}
+export function parseHostedRepository(value) {
+    const parts = value.split('/');
+    if (parts.length !== 2
+        || !parts.every(part => REPOSITORY_COMPONENT.test(part))) {
+        throw new Error(`Invalid repository "${value}". Use an exact GitHub owner/repository name.`);
+    }
+    return {
+        owner: parts[0],
+        repository: parts[1],
+        fullName: value,
+    };
+}
+function requireCommit(value, flag) {
+    if (typeof value !== 'string' || !COMMIT_SHA.test(value)) {
+        throw new Error(`${flag} must be an exact 40-character lowercase commit SHA.`);
+    }
+    return value;
+}
+export function defaultHostedIdempotencyKey(repository, baseCommit, headCommit) {
+    const digest = createHash('sha256')
+        .update(JSON.stringify([repository, baseCommit, headCommit]))
+        .digest('hex');
+    return `cli:${digest}`;
+}
+function requireIdempotencyKey(value) {
+    if (!IDEMPOTENCY_KEY.test(value)) {
+        throw new Error('--idempotency-key must be 8-128 characters and use only letters, numbers, ".", "_", ":", or "-".');
+    }
+    return value;
+}
+function parsePositiveNumber(value, fallback, flag, maximum) {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > maximum) {
+        throw new Error(`${flag} must be a positive number no greater than ${maximum}.`);
+    }
+    return parsed;
+}
+function pollingOptions(interval, timeout, onStatus) {
+    return {
+        intervalMs: parsePositiveNumber(interval, DEFAULT_INTERVAL_SECONDS, '--interval', 300) * 1000,
+        timeoutMs: parsePositiveNumber(timeout, DEFAULT_TIMEOUT_MINUTES, '--timeout', 1_440) * 60_000,
+        onStatus,
+    };
+}
+export async function startHostedVerification(repositoryArg, options, token) {
+    const repository = parseHostedRepository(repositoryArg);
+    const baseCommit = requireCommit(options.base, '--base');
+    const headCommit = requireCommit(options.head, '--head');
+    const idempotencyKey = requireIdempotencyKey(options.idempotencyKey
+        ?? defaultHostedIdempotencyKey(repository.fullName, baseCommit, headCommit));
+    const response = await haystackJson('/api/agent/cloud-verifier/runs', token, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            owner: repository.owner,
+            repository: repository.repository,
+            baseCommit,
+            headCommit,
+            idempotencyKey,
+        }),
+    });
+    const state = parseHostedRunState(response);
+    return {
+        state: {
+            ...state,
+            repository: state.repository ?? repository.fullName,
+            baseCommit: state.baseCommit ?? baseCommit,
+            headCommit: state.headCommit ?? headCommit,
+        },
+        idempotencyKey,
+    };
+}
+export async function getHostedVerification(runId, token) {
+    if (!RUN_ID.test(runId)) {
+        throw new Error('Run id must match cv_ followed by 48 lowercase hex characters.');
+    }
+    let response;
+    try {
+        response = await haystackJson(`/api/agent/cloud-verifier/runs/${encodeURIComponent(runId)}`, token, {}, [410]);
+    }
+    catch (error) {
+        if (error instanceof HaystackApiError && error.status === 404) {
+            throw new Error(`Hosted verifier run ${runId} was not found for the selected account. `
+                + 'If the run was started with another saved account, retry with `--account <login>`.');
+        }
+        throw error;
+    }
+    return parseHostedRunState(response, runId);
+}
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+export async function waitForHostedVerification(runId, token, options) {
+    const startedAt = Date.now();
+    let lastStatus;
+    while (true) {
+        const state = await getHostedVerification(runId, token);
+        if (state.status !== lastStatus) {
+            options.onStatus?.(state);
+            lastStatus = state.status;
+        }
+        if (TERMINAL_STATUSES.has(state.status)) {
+            return { state, timedOut: false };
+        }
+        const elapsed = Date.now() - startedAt;
+        if (elapsed >= options.timeoutMs) {
+            return { state, timedOut: true };
+        }
+        await delay(Math.min(options.intervalMs, options.timeoutMs - elapsed));
+    }
+}
+export function buildHostedJson(operation, state, extras = {}) {
+    return withSchema('cloud-verifier', {
+        operation,
+        run_id: state.runId,
+        status: state.status,
+        ...(state.repository ? { repository: state.repository } : {}),
+        ...(state.baseCommit ? { base_commit: state.baseCommit } : {}),
+        ...(state.headCommit ? { head_commit: state.headCommit } : {}),
+        ...(state.createdAt ? { created_at: state.createdAt } : {}),
+        ...(state.completedAt ? { completed_at: state.completedAt } : {}),
+        ...(extras.account ? { account: extras.account } : {}),
+        ...(extras.idempotencyKey
+            ? { idempotency_key: extras.idempotencyKey }
+            : {}),
+        ...(extras.nextCommand ? { next_command: extras.nextCommand } : {}),
+        ...(extras.timedOut !== undefined ? { timed_out: extras.timedOut } : {}),
+        ...(state.output ? { output: state.output } : {}),
+        ...(state.error ? { error: state.error } : {}),
+    });
+}
+export function hostedResumeCommand(runId, account) {
+    return `haystack verify hosted status ${runId}${account ? ` --account ${account}` : ''} --wait`;
+}
+function printHostedState(operation, state, options) {
+    const nextCommand = TERMINAL_STATUSES.has(state.status)
+        ? undefined
+        : hostedResumeCommand(state.runId, options.account);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(buildHostedJson(operation, state, {
+            account: options.account,
+            idempotencyKey: options.idempotencyKey,
+            nextCommand,
+            timedOut: options.timedOut,
+        }), null, 2)}\n`);
+        return;
+    }
+    const icon = state.status === 'complete'
+        ? chalk.green('✓')
+        : TERMINAL_STATUSES.has(state.status)
+            ? chalk.red('✗')
+            : chalk.cyan('•');
+    console.log(`${icon} Hosted verification ${chalk.bold(state.runId)}: ${state.status}`);
+    if (state.repository) {
+        console.log(`  ${chalk.dim('Repository:')} ${state.repository}`);
+    }
+    if (state.baseCommit && state.headCommit) {
+        console.log(`  ${chalk.dim('Commits:')} ${state.baseCommit.slice(0, 12)} → ${state.headCommit.slice(0, 12)}`);
+    }
+    if (state.error)
+        console.log(`  ${chalk.dim('Error:')} ${state.error}`);
+    if (options.timedOut) {
+        console.log(chalk.yellow('  Wait timed out; the production run is still active.'));
+    }
+    if (nextCommand)
+        console.log(`  ${chalk.dim('Resume:')} ${nextCommand}`);
+}
+function markNonSuccess(state, timedOut = false) {
+    if (timedOut
+        || (state.status !== 'complete' && TERMINAL_STATUSES.has(state.status))) {
+        process.exitCode = 2;
+    }
+}
+export async function verifyHostedStartCommand(repositoryArg, options) {
+    const repository = parseHostedRepository(repositoryArg);
+    const auth = await resolveAuthContext({
+        preferredLogin: options.account,
+        owner: repository.owner,
+        repo: repository.repository,
+    });
+    if (!options.json) {
+        console.error(chalk.dim('Submitting the exact commit pair to the hosted verifier…'));
+    }
+    const started = await startHostedVerification(repositoryArg, options, auth.token);
+    const selectedAccount = auth.token.startsWith('hsk_live_')
+        ? undefined
+        : auth.login;
+    let state = started.state;
+    let timedOut;
+    if (options.wait !== false && !TERMINAL_STATUSES.has(state.status)) {
+        const waited = await waitForHostedVerification(state.runId, auth.token, pollingOptions(options.interval, options.timeout, current => {
+            if (!options.json) {
+                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
+            }
+        }));
+        state = waited.state;
+        timedOut = waited.timedOut;
+    }
+    else if (options.wait !== false) {
+        timedOut = false;
+    }
+    printHostedState('start', state, {
+        json: options.json,
+        account: selectedAccount,
+        idempotencyKey: started.idempotencyKey,
+        timedOut,
+    });
+    markNonSuccess(state, timedOut);
+}
+export async function verifyHostedStatusCommand(runId, options) {
+    const auth = await resolveAuthContext({ preferredLogin: options.account });
+    const selectedAccount = auth.token.startsWith('hsk_live_')
+        ? undefined
+        : auth.login;
+    let state = await getHostedVerification(runId, auth.token);
+    let timedOut;
+    if (options.wait && !TERMINAL_STATUSES.has(state.status)) {
+        const waited = await waitForHostedVerification(runId, auth.token, pollingOptions(options.interval, options.timeout, current => {
+            if (!options.json) {
+                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
+            }
+        }));
+        state = waited.state;
+        timedOut = waited.timedOut;
+    }
+    else if (options.wait) {
+        timedOut = false;
+    }
+    printHostedState('status', state, {
+        json: options.json,
+        account: selectedAccount,
+        timedOut,
+    });
+    markNonSuccess(state, timedOut);
+}

package/dist/commands/verify-mcp.d.ts

@@ -0,0 +1,8 @@
+import { type Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const VERIFY_TOOLS: Tool[];
+export interface VerifyMcpOptions {
+    server?: string;
+    repoRoot?: string;
+    token?: string;
+}
+export declare function runVerifyMcpServer(options: VerifyMcpOptions): Promise<void>;