gitpadi 2.0.6 → 2.1.1

package/src/core/gitlab.ts

@@ -0,0 +1,397 @@
+// core/gitlab.ts — GitLab REST API client for GitPadi
+//
+// Mirrors the interface of github.ts so CLI commands can be
+// written once and routed to either platform.
+
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import os from 'node:os';
+import { execFileSync } from 'child_process';
+
+const CONFIG_DIR = path.join(os.homedir(), '.gitpadi');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+// ── State ──────────────────────────────────────────────────────────────
+let _token: string = '';
+let _host: string = 'https://gitlab.com';
+let _namespace: string = '';   // equivalent of "owner"
+let _project: string = '';     // equivalent of "repo"
+
+// ── Config (shared file with github.ts) ───────────────────────────────
+interface GitPadiFullConfig {
+    token?: string;
+    owner?: string;
+    repo?: string;
+    gitlabToken?: string;
+    gitlabHost?: string;
+    gitlabNamespace?: string;
+    gitlabProject?: string;
+    platform?: 'github' | 'gitlab';
+}
+
+function loadFullConfig(): GitPadiFullConfig {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')); } catch { return {}; }
+}
+
+function saveFullConfig(patch: Partial<GitPadiFullConfig>): void {
+    const current = loadFullConfig();
+    const updated = { ...current, ...patch };
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+}
+
+// ── Local repo detection ───────────────────────────────────────────────
+export function detectLocalGitLabRepo(): { namespace: string; project: string } | null {
+    try {
+        const remotes = execFileSync('git', ['remote', '-v'], { encoding: 'utf-8', stdio: 'pipe' });
+        // Match both gitlab.com/ns/proj and self-hosted instances
+        const match = remotes.match(/gitlab[^/]*[:/]([^/]+)\/([^/.]+)(?:\.git)?/);
+        if (match) return { namespace: match[1], project: match[2] };
+    } catch { /* not a git repo */ }
+    return null;
+}
+
+// ── Init ───────────────────────────────────────────────────────────────
+export function initGitLab(token?: string, namespace?: string, project?: string, host?: string): void {
+    const config = loadFullConfig();
+    const detected = detectLocalGitLabRepo();
+
+    _token = token || process.env.GITLAB_TOKEN || process.env.GITPADI_GITLAB_TOKEN || config.gitlabToken || '';
+    _host = host || process.env.GITLAB_HOST || config.gitlabHost || 'https://gitlab.com';
+    _namespace = namespace || process.env.GITLAB_NAMESPACE || config.gitlabNamespace || detected?.namespace || '';
+    _project = project || process.env.GITLAB_PROJECT || config.gitlabProject || detected?.project || '';
+}
+
+export function getGitLabToken(): string { return _token; }
+export function getGitLabHost(): string { return _host; }
+export function getNamespace(): string { return _namespace; }
+export function getProject(): string { return _project; }
+export function getFullProject(): string { return `${_namespace}/${_project}`; }
+
+export function setGitLabProject(namespace: string, project: string): void {
+    _namespace = namespace;
+    _project = project;
+    if (_token) saveFullConfig({ gitlabNamespace: namespace, gitlabProject: project });
+}
+
+export function saveGitLabConfig(token: string, host: string, namespace: string, project: string): void {
+    _token = token;
+    _host = host;
+    _namespace = namespace;
+    _project = project;
+    saveFullConfig({ gitlabToken: token, gitlabHost: host, gitlabNamespace: namespace, gitlabProject: project, platform: 'gitlab' });
+}
+
+export function savePlatformPreference(platform: 'github' | 'gitlab'): void {
+    saveFullConfig({ platform });
+}
+
+export function loadPlatformPreference(): 'github' | 'gitlab' | undefined {
+    return loadFullConfig().platform;
+}
+
+export function requireGitLabProject(): void {
+    if (!_namespace || !_project) {
+        console.error(chalk.red('\n❌ GitLab project not set.'));
+        console.error(chalk.dim('   Set GITLAB_NAMESPACE and GITLAB_PROJECT env vars, or run gitpadi and select a project.\n'));
+        process.exit(1);
+    }
+}
+
+// ── HTTP helpers ───────────────────────────────────────────────────────
+function apiUrl(path: string): string {
+    const base = _host.replace(/\/$/, '');
+    return `${base}/api/v4${path}`;
+}
+
+async function glFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const res = await fetch(apiUrl(path), {
+        method,
+        headers: {
+            'PRIVATE-TOKEN': _token,
+            'Content-Type': 'application/json',
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw Object.assign(new Error(`GitLab API ${method} ${path} → ${res.status}: ${text}`), { status: res.status });
+    }
+
+    const text = await res.text();
+    return text ? JSON.parse(text) as T : ({} as T);
+}
+
+const gl = {
+    get: <T>(path: string) => glFetch<T>('GET', path),
+    post: <T>(path: string, body: unknown) => glFetch<T>('POST', path, body),
+    put: <T>(path: string, body: unknown) => glFetch<T>('PUT', path, body),
+    delete: <T>(path: string) => glFetch<T>('DELETE', path),
+};
+
+// Encode "namespace/project" → "namespace%2Fproject" for URL path segments
+function encodeProject(ns: string, proj: string): string {
+    return encodeURIComponent(`${ns}/${proj}`);
+}
+
+// ── Rate-limit retry ───────────────────────────────────────────────────
+export async function withGitLabRetry<T>(fn: () => Promise<T>, maxRetries = 4): Promise<T> {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        } catch (e: any) {
+            const isRateLimit = e.status === 429 || (e.status === 403 && /rate limit/i.test(e.message || ''));
+            if (isRateLimit && attempt < maxRetries) {
+                const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500;
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            throw e;
+        }
+    }
+    throw new Error('withGitLabRetry: max retries exceeded');
+}
+
+// ── User ───────────────────────────────────────────────────────────────
+export interface GitLabUser {
+    id: number;
+    username: string;
+    name: string;
+    avatar_url: string;
+    web_url: string;
+    created_at: string;
+    public_repos?: number;
+}
+
+export async function getAuthenticatedGitLabUser(): Promise<GitLabUser> {
+    return gl.get<GitLabUser>('/user');
+}
+
+// ── Project ────────────────────────────────────────────────────────────
+export interface GitLabProject {
+    id: number;
+    name: string;
+    path_with_namespace: string;
+    description: string | null;
+    web_url: string;
+    default_branch: string;
+    visibility: string;
+    star_count: number;
+    forks_count: number;
+    open_issues_count: number;
+    permissions?: { project_access?: { access_level: number } };
+}
+
+export async function getGitLabProject(namespace: string, project: string): Promise<GitLabProject> {
+    return gl.get<GitLabProject>(`/projects/${encodeProject(namespace, project)}`);
+}
+
+export async function forkGitLabProject(namespace: string, project: string): Promise<GitLabProject> {
+    return gl.post<GitLabProject>(`/projects/${encodeProject(namespace, project)}/fork`, {});
+}
+
+// ── Issues ─────────────────────────────────────────────────────────────
+export interface GitLabIssue {
+    id: number;
+    iid: number;            // project-scoped issue number (equivalent to GitHub issue number)
+    title: string;
+    description: string | null;
+    state: 'opened' | 'closed';
+    author: { username: string };
+    assignees: Array<{ username: string }>;
+    labels: string[];
+    created_at: string;
+    updated_at: string;
+    web_url: string;
+}
+
+export async function listGitLabIssues(namespace: string, project: string, opts: {
+    state?: 'opened' | 'closed' | 'all';
+    per_page?: number;
+    labels?: string;
+} = {}): Promise<GitLabIssue[]> {
+    const params = new URLSearchParams({
+        state: opts.state || 'opened',
+        per_page: String(opts.per_page || 50),
+    });
+    if (opts.labels) params.set('labels', opts.labels);
+    return gl.get<GitLabIssue[]>(`/projects/${encodeProject(namespace, project)}/issues?${params}`);
+}
+
+export async function createGitLabIssue(namespace: string, project: string, data: {
+    title: string;
+    description?: string;
+    labels?: string;
+    assignee_ids?: number[];
+}): Promise<GitLabIssue> {
+    return gl.post<GitLabIssue>(`/projects/${encodeProject(namespace, project)}/issues`, data);
+}
+
+export async function updateGitLabIssue(namespace: string, project: string, iid: number, data: {
+    state_event?: 'close' | 'reopen';
+    title?: string;
+    description?: string;
+}): Promise<GitLabIssue> {
+    return gl.put<GitLabIssue>(`/projects/${encodeProject(namespace, project)}/issues/${iid}`, data);
+}
+
+export async function createGitLabIssueNote(namespace: string, project: string, iid: number, body: string): Promise<void> {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/issues/${iid}/notes`, { body });
+}
+
+// ── Merge Requests ─────────────────────────────────────────────────────
+export interface GitLabMR {
+    id: number;
+    iid: number;
+    title: string;
+    description: string | null;
+    state: 'opened' | 'closed' | 'locked' | 'merged';
+    author: { username: string };
+    source_branch: string;
+    target_branch: string;
+    web_url: string;
+    sha: string;
+    draft: boolean;
+    has_conflicts: boolean;
+    created_at: string;
+    updated_at: string;
+    merge_status: string;
+}
+
+export async function listGitLabMRs(namespace: string, project: string, opts: {
+    state?: 'opened' | 'closed' | 'locked' | 'merged' | 'all';
+    per_page?: number;
+} = {}): Promise<GitLabMR[]> {
+    const params = new URLSearchParams({
+        state: opts.state || 'opened',
+        per_page: String(opts.per_page || 50),
+    });
+    return gl.get<GitLabMR[]>(`/projects/${encodeProject(namespace, project)}/merge_requests?${params}`);
+}
+
+export async function getGitLabMR(namespace: string, project: string, iid: number): Promise<GitLabMR> {
+    return gl.get<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`);
+}
+
+export async function createGitLabMR(namespace: string, project: string, data: {
+    title: string;
+    description?: string;
+    source_branch: string;
+    target_branch: string;
+    remove_source_branch?: boolean;
+    squash?: boolean;
+}): Promise<GitLabMR> {
+    return gl.post<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests`, {
+        remove_source_branch: true,
+        ...data,
+    });
+}
+
+export async function mergeGitLabMR(namespace: string, project: string, iid: number, opts: {
+    squash?: boolean;
+    message?: string;
+} = {}): Promise<GitLabMR> {
+    return gl.put<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/merge`, {
+        squash: opts.squash ?? true,
+        squash_commit_message: opts.message,
+    });
+}
+
+export async function updateGitLabMR(namespace: string, project: string, iid: number, data: {
+    state_event?: 'close' | 'reopen';
+    title?: string;
+}): Promise<GitLabMR> {
+    return gl.put<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`, data);
+}
+
+export async function listGitLabMRNotes(namespace: string, project: string, iid: number): Promise<Array<{
+    id: number; body: string; author: { username: string }; created_at: string;
+}>> {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes?per_page=100`);
+}
+
+export async function createGitLabMRNote(namespace: string, project: string, iid: number, body: string): Promise<void> {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes`, { body });
+}
+
+export async function updateGitLabMRNote(namespace: string, project: string, iid: number, noteId: number, body: string): Promise<void> {
+    await gl.put(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes/${noteId}`, { body });
+}
+
+export async function listGitLabMRChanges(namespace: string, project: string, iid: number): Promise<Array<{
+    old_path: string; new_path: string; new_file: boolean; deleted_file: boolean; diff: string;
+}>> {
+    const data = await gl.get<{ changes: any[] }>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/changes`);
+    return data.changes || [];
+}
+
+// ── Pipelines ──────────────────────────────────────────────────────────
+export interface GitLabPipeline {
+    id: number;
+    iid: number;
+    status: 'created' | 'waiting_for_resource' | 'preparing' | 'pending' | 'running' | 'success' | 'failed' | 'canceled' | 'skipped' | 'manual' | 'scheduled';
+    source: string;
+    ref: string;
+    sha: string;
+    web_url: string;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface GitLabJob {
+    id: number;
+    name: string;
+    stage: string;
+    status: string;
+    web_url: string;
+    created_at: string;
+    started_at: string | null;
+    finished_at: string | null;
+    duration: number | null;
+}
+
+export async function listGitLabPipelines(namespace: string, project: string, opts: {
+    per_page?: number;
+    ref?: string;
+    status?: string;
+} = {}): Promise<GitLabPipeline[]> {
+    const params = new URLSearchParams({ per_page: String(opts.per_page || 20) });
+    if (opts.ref) params.set('ref', opts.ref);
+    if (opts.status) params.set('status', opts.status);
+    return gl.get<GitLabPipeline[]>(`/projects/${encodeProject(namespace, project)}/pipelines?${params}`);
+}
+
+export async function getGitLabPipeline(namespace: string, project: string, pipelineId: number): Promise<GitLabPipeline> {
+    return gl.get<GitLabPipeline>(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}`);
+}
+
+export async function listGitLabPipelineJobs(namespace: string, project: string, pipelineId: number): Promise<GitLabJob[]> {
+    return gl.get<GitLabJob[]>(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}/jobs?per_page=100`);
+}
+
+export async function getGitLabJobLog(namespace: string, project: string, jobId: number): Promise<string> {
+    const res = await fetch(apiUrl(`/projects/${encodeProject(namespace, project)}/jobs/${jobId}/trace`), {
+        headers: { 'PRIVATE-TOKEN': _token },
+    });
+    if (!res.ok) throw new Error(`Could not fetch job log: ${res.status}`);
+    return res.text();
+}
+
+// ── MR CI status (for polling) ─────────────────────────────────────────
+export async function getGitLabMRPipelineStatus(namespace: string, project: string, mrIid: number): Promise<{
+    status: string;
+    web_url: string;
+} | null> {
+    try {
+        const pipelines = await gl.get<GitLabPipeline[]>(
+            `/projects/${encodeProject(namespace, project)}/merge_requests/${mrIid}/pipelines?per_page=1`
+        );
+        if (!pipelines.length) return null;
+        return { status: pipelines[0].status, web_url: pipelines[0].web_url };
+    } catch {
+        return null;
+    }
+}

package/src/gitlab-agents/ci-recovery-agent.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// gitlab-agents/ci-recovery-agent.ts
+//
+// GitLab Duo External Agent — AI-powered CI Failure Recovery
+//
+// Triggered when a pipeline fails on an MR.
+// Claude reads the full failure logs, identifies root causes, and:
+//   1. Posts a diagnosis comment on the MR explaining what failed and why
+//   2. Suggests specific fixes with code snippets
+//   3. (Optional) Creates a fix commit if AUTO_FIX=true
+
+import Anthropic from '@anthropic-ai/sdk';
+
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN || '';
+const GITLAB_HOST = (process.env.GITLAB_HOST || 'https://gitlab.com').replace(/\/$/, '');
+const GATEWAY_TOKEN = process.env.AI_FLOW_AI_GATEWAY_TOKEN || '';
+
+const anthropic = GATEWAY_TOKEN
+    ? new Anthropic({ apiKey: GATEWAY_TOKEN, baseURL: `${GITLAB_HOST}/api/v4/ai/llm/v1` })
+    : new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+const CI_RECOVERY_MARKER = '<!-- gitpadi-ci-recovery -->';
+
+async function glFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const res = await fetch(`${GITLAB_HOST}/api/v4${path}`, {
+        method,
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN, 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) throw new Error(`GitLab ${method} ${path} → ${res.status}`);
+    return res.json() as Promise<T>;
+}
+
+async function getJobLog(projectId: number, jobId: number): Promise<string> {
+    const res = await fetch(`${GITLAB_HOST}/api/v4/projects/${projectId}/jobs/${jobId}/trace`, {
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN },
+    });
+    if (!res.ok) return 'Log unavailable';
+    const text = await res.text();
+    // Return last 3000 chars — most errors are at the end
+    return text.length > 3000 ? `...\n${text.slice(-3000)}` : text;
+}
+
+async function postOrUpdateMRNote(projectId: number, mrIid: number, body: string): Promise<void> {
+    const notes = await glFetch<Array<{ id: number; body: string }>>(
+        'GET', `/projects/${projectId}/merge_requests/${mrIid}/notes?per_page=100`
+    );
+    const existing = notes.find(n => n.body?.includes(CI_RECOVERY_MARKER));
+    if (existing) {
+        await glFetch('PUT', `/projects/${projectId}/merge_requests/${mrIid}/notes/${existing.id}`, { body });
+    } else {
+        await glFetch('POST', `/projects/${projectId}/merge_requests/${mrIid}/notes`, { body });
+    }
+}
+
+async function main(): Promise<void> {
+    console.log('\n🤖 GitPadi CI Recovery Agent\n');
+
+    const contextRaw = process.env.AI_FLOW_CONTEXT || '{}';
+    let context: any;
+    try { context = JSON.parse(contextRaw); } catch { context = {}; }
+
+    const {
+        project_id,
+        project_path = '',
+        mr_iid,
+        pipeline_id,
+        title = '',
+        source_branch = '',
+        author = '',
+        failed_jobs = [],
+    } = context;
+
+    if (!mr_iid || !pipeline_id) {
+        console.log('⏭️ No MR/pipeline context — skipping.');
+        return;
+    }
+
+    console.log(`  Project:  ${project_path}`);
+    console.log(`  MR:       !${mr_iid} — ${title}`);
+    console.log(`  Pipeline: #${pipeline_id}`);
+    console.log(`  Failed:   ${failed_jobs.length} job(s)\n`);
+
+    // Fetch all failed jobs if not in context
+    let jobs = failed_jobs;
+    if (!jobs.length) {
+        try {
+            const allJobs = await glFetch<Array<{ id: number; name: string; status: string; stage: string }>>(
+                'GET', `/projects/${project_id}/pipelines/${pipeline_id}/jobs?per_page=100`
+            );
+            jobs = allJobs.filter((j: any) => j.status === 'failed');
+        } catch {
+            jobs = [];
+        }
+    }
+
+    if (!jobs.length) {
+        console.log('  No failed jobs found.');
+        return;
+    }
+
+    // Collect logs from failed jobs
+    console.log('  Fetching failure logs...');
+    const jobLogs: Array<{ name: string; stage: string; log: string }> = [];
+    for (const job of jobs.slice(0, 3)) { // max 3 jobs to avoid token overload
+        const log = await getJobLog(project_id, job.id);
+        jobLogs.push({ name: job.name, stage: job.stage || 'unknown', log });
+        console.log(`  ✓ Fetched log for: ${job.name}`);
+    }
+
+    // Ask Claude to diagnose
+    const prompt = `You are GitPadi, an AI DevOps assistant integrated with GitLab.
+
+A CI pipeline failed on this Merge Request:
+- MR: !${mr_iid} — "${title}"
+- Author: @${author}
+- Branch: ${source_branch}
+
+Failed job logs:
+${jobLogs.map(j => `\n### Job: ${j.name} (stage: ${j.stage})\n\`\`\`\n${j.log}\n\`\`\``).join('\n')}
+
+Analyze these failures and provide:
+1. Root cause diagnosis for each failure
+2. Specific fix recommendations with code snippets where possible
+3. Priority order of fixes
+
+Respond as JSON:
+{
+  "failures": [
+    {
+      "job": "job name",
+      "rootCause": "explanation",
+      "errorType": "lint|test|build|type|other",
+      "fix": {
+        "description": "what to change",
+        "codeSnippet": "code if applicable, null otherwise",
+        "commands": ["shell commands if applicable"]
+      },
+      "confidence": "high|medium|low"
+    }
+  ],
+  "quickFix": "single most impactful thing to fix first",
+  "estimatedFixTime": "e.g. 5 minutes",
+  "summary": "overall diagnosis in 2-3 sentences"
+}`;
+
+    let diagnosis: any;
+    try {
+        const response = await anthropic.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 2048,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const text = response.content[0].type === 'text' ? response.content[0].text : '';
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) throw new Error('No JSON');
+        diagnosis = JSON.parse(jsonMatch[0]);
+    } catch (e: any) {
+        console.error(`❌ Claude diagnosis failed: ${e.message}`);
+        process.exit(1);
+    }
+
+    // Build the recovery comment
+    let comment = `## 🤖 GitPadi — CI Failure Recovery\n\n`;
+    comment += `**Pipeline:** #${pipeline_id} | **Failed jobs:** ${jobs.length}\n\n`;
+
+    comment += `### Diagnosis\n\n${diagnosis.summary}\n\n`;
+
+    if (diagnosis.quickFix) {
+        comment += `> 🚀 **Quick Fix:** ${diagnosis.quickFix}\n`;
+        comment += `> ⏱️ **Estimated fix time:** ${diagnosis.estimatedFixTime || 'a few minutes'}\n\n`;
+    }
+
+    diagnosis.failures?.forEach((f: any, i: number) => {
+        const confIcon = f.confidence === 'high' ? '🔴' : f.confidence === 'medium' ? '🟡' : '🟢';
+        comment += `### ${i + 1}. \`${f.job}\`\n\n`;
+        comment += `**Root Cause:** ${f.rootCause}\n\n`;
+
+        if (f.fix) {
+            comment += `**Fix:** ${f.fix.description}\n\n`;
+            if (f.fix.codeSnippet) {
+                comment += `\`\`\`\n${f.fix.codeSnippet}\n\`\`\`\n\n`;
+            }
+            if (f.fix.commands?.length) {
+                comment += `Run:\n\`\`\`bash\n${f.fix.commands.join('\n')}\n\`\`\`\n\n`;
+            }
+        }
+
+        comment += `${confIcon} Confidence: ${f.confidence}\n\n`;
+    });
+
+    comment += `---\n`;
+    comment += `_🤖 Diagnosed by [GitPadi](https://github.com/Netwalls/contributor-agent) using Claude — [Fix & Re-push](https://github.com/Netwalls/contributor-agent#fix--re-push) when ready_\n\n`;
+    comment += CI_RECOVERY_MARKER;
+
+    await postOrUpdateMRNote(project_id, mr_iid, comment);
+    console.log(`\n✅ Recovery guide posted to MR !${mr_iid}`);
+    console.log(`   ${diagnosis.failures?.length || 0} failure(s) diagnosed`);
+}
+
+main().catch(e => { console.error('Fatal:', e.message); process.exit(1); });