profclaw 0.0.1-beta.1

package/dist/integrations/jira-client.js

@@ -0,0 +1,67 @@
+import { logger } from '../utils/logger.js';
+/**
+ * Jira API Client
+ *
+ * Supports adding comments and updating issue status.
+ */
+export class JiraClient {
+    baseUrl;
+    email;
+    apiToken;
+    authHeader;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.email = config.email;
+        this.apiToken = config.apiToken;
+        this.authHeader = config.authHeader;
+        if (!this.authHeader && this.email && this.apiToken) {
+            const creds = Buffer.from(`${this.email}:${this.apiToken}`).toString('base64');
+            this.authHeader = `Basic ${creds}`;
+        }
+    }
+    /**
+     * Add a comment to a Jira issue
+     */
+    async addComment(issueKey, body) {
+        const path = `/rest/api/2/issue/${issueKey}/comment`;
+        await this.request(path, {
+            method: 'POST',
+            body: JSON.stringify({ body }),
+        });
+    }
+    /**
+     * Update issue status (transition)
+     */
+    async transitionIssue(issueKey, transitionId) {
+        const path = `/rest/api/2/issue/${issueKey}/transitions`;
+        await this.request(path, {
+            method: 'POST',
+            body: JSON.stringify({
+                transition: { id: transitionId },
+            }),
+        });
+    }
+    /**
+     * Internal request helper
+     */
+    async request(path, options) {
+        const url = `${this.baseUrl}${path}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': this.authHeader || '',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.error(`[Jira Client] Error ${response.status} on ${path}:`, new Error(errorText));
+            throw new Error(`Jira API error: ${response.status} ${response.statusText}`);
+        }
+        if (response.status === 204)
+            return null;
+        return await response.json();
+    }
+}
+//# sourceMappingURL=jira-client.js.map

package/dist/integrations/jira.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from 'hono';
+import type { CreateTaskInput } from '../types/task.js';
+/**
+ * Verify Jira webhook token
+ *
+ * Checks for ?token=SECRET in query params
+ */
+export declare function verifyJiraToken(c: Context): boolean;
+/**
+ * Handle Jira webhook
+ */
+export declare function handleJiraWebhook(c: Context): Promise<CreateTaskInput | null>;
+//# sourceMappingURL=jira.d.ts.map

package/dist/integrations/jira.js

@@ -0,0 +1,108 @@
+/**
+ * Jira Webhook Integration
+ *
+ * Receives webhooks from Jira and creates tasks from issues.
+ *
+ * Supported events:
+ * - jira:issue_created
+ * - jira:issue_updated
+ */
+const JIRA_AI_TASK_LABEL = process.env.JIRA_AI_TASK_LABEL || 'ai-task';
+const WEBHOOK_SECRET = process.env.JIRA_WEBHOOK_SECRET || '';
+/**
+ * Verify Jira webhook token
+ *
+ * Checks for ?token=SECRET in query params
+ */
+export function verifyJiraToken(c) {
+    if (!WEBHOOK_SECRET) {
+        console.warn('JIRA_WEBHOOK_SECRET not set - skipping verification');
+        return true;
+    }
+    const token = c.req.query('token');
+    return token === WEBHOOK_SECRET;
+}
+/**
+ * Handle Jira webhook
+ */
+export async function handleJiraWebhook(c) {
+    // Verify token
+    if (!verifyJiraToken(c)) {
+        throw new Error('Invalid webhook token');
+    }
+    const rawBody = await c.req.text();
+    const payload = JSON.parse(rawBody);
+    const { webhookEvent, issue } = payload;
+    console.log(`[Jira Webhook] Event: ${webhookEvent}, Issue: ${issue.key}`);
+    // Only handle created or updated events
+    if (webhookEvent !== 'jira:issue_created' && webhookEvent !== 'jira:issue_updated') {
+        return null;
+    }
+    // Check for AI label
+    const hasAiLabel = issue.fields.labels?.includes(JIRA_AI_TASK_LABEL);
+    if (!hasAiLabel) {
+        console.log('[Jira] Issue does not have AI label, skipping');
+        return null;
+    }
+    // Construct source URL (convert API URL to browser URL)
+    // e.g. https://site.atlassian.net/rest/api/2/issue/10001 -> https://site.atlassian.net/browse/TEST-1
+    let sourceUrl = undefined;
+    if (issue.self) {
+        try {
+            const baseUrl = new URL(issue.self).origin;
+            sourceUrl = `${baseUrl}/browse/${issue.key}`;
+        }
+        catch {
+            // Ignore URL parsing error
+        }
+    }
+    return {
+        title: `Jira Issue ${issue.key}: ${issue.fields.summary}`,
+        description: issue.fields.description || undefined,
+        prompt: buildPromptFromJiraIssue(issue),
+        priority: getPriorityFromJiraPriority(issue.fields.priority?.name),
+        source: 'jira',
+        sourceId: issue.key,
+        sourceUrl,
+        labels: issue.fields.labels || [],
+        metadata: {
+            issueId: issue.id,
+            key: issue.key,
+            reporter: issue.fields.reporter?.displayName,
+            reporterEmail: issue.fields.reporter?.emailAddress,
+            status: issue.fields.status?.name,
+            created: issue.fields.created,
+        },
+    };
+}
+/**
+ * Build AI prompt from Jira issue
+ */
+function buildPromptFromJiraIssue(issue) {
+    const parts = [];
+    parts.push(`Jira Issue ${issue.key}: ${issue.fields.summary}`);
+    if (issue.fields.description) {
+        parts.push('\n## Issue Description:');
+        parts.push(issue.fields.description);
+    }
+    parts.push('\n## Task:');
+    parts.push('Please analyze this Jira issue and implement the requested work.');
+    parts.push('Create atomic commits with clear messages.');
+    return parts.join('\n');
+}
+/**
+ * Get priority from Jira priority name
+ */
+function getPriorityFromJiraPriority(priorityName) {
+    if (!priorityName)
+        return 3;
+    const name = priorityName.toLowerCase();
+    if (name.includes('critical') || name.includes('highest'))
+        return 1;
+    if (name.includes('high'))
+        return 2;
+    if (name.includes('low') || name.includes('lowest'))
+        return 4;
+    return 3; // Default medium
+}
+//# sourceMappingURL=jira.js.map

package/dist/integrations/linear-client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Linear API Client
+ *
+ * Uses GraphQL to interact with Linear issues.
+ */
+export declare class LinearClient {
+    private apiKey?;
+    private authHeader?;
+    private endpoint;
+    constructor(config: {
+        apiKey?: string;
+        authHeader?: string;
+    });
+    /**
+     * Add a comment to a Linear issue
+     */
+    addComment(issueId: string, body: string): Promise<void>;
+    /**
+     * Internal request helper for GraphQL
+     */
+    private request;
+}
+//# sourceMappingURL=linear-client.d.ts.map

package/dist/integrations/linear-client.js

@@ -0,0 +1,52 @@
+import { logger } from '../utils/logger.js';
+/**
+ * Linear API Client
+ *
+ * Uses GraphQL to interact with Linear issues.
+ */
+export class LinearClient {
+    apiKey;
+    authHeader;
+    endpoint = 'https://api.linear.app/graphql';
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.authHeader = config.authHeader || (this.apiKey ? `${this.apiKey}` : undefined);
+    }
+    /**
+     * Add a comment to a Linear issue
+     */
+    async addComment(issueId, body) {
+        const query = `
+      mutation CreateComment($issueId: String!, $body: String!) {
+        commentCreate(input: { issueId: $issueId, body: $body }) {
+          success
+          comment {
+            id
+          }
+        }
+      }
+    `;
+        await this.request(query, { issueId, body });
+    }
+    /**
+     * Internal request helper for GraphQL
+     */
+    async request(query, variables) {
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': this.authHeader || '',
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        const result = await response.json();
+        if (!response.ok || result.errors) {
+            const error = result.errors ? result.errors[0].message : response.statusText;
+            logger.error('[Linear Client] API Error:', new Error(error));
+            throw new Error(`Linear API error: ${error}`);
+        }
+        return result.data ?? null;
+    }
+}
+//# sourceMappingURL=linear-client.js.map

package/dist/integrations/linear.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Linear Webhook Integration
+ *
+ * Handles webhooks from Linear to automatically create tasks when:
+ * - Issues are created with specific labels
+ * - Issues are updated with AI-task label
+ * - Issues have specific commands in comments
+ */
+import type { Context } from 'hono';
+import type { CreateTaskInput } from '../types/task.js';
+/**
+ * Handle Linear webhook
+ */
+export declare function handleLinearWebhook(c: Context): Promise<CreateTaskInput | null>;
+//# sourceMappingURL=linear.d.ts.map

package/dist/integrations/linear.js

@@ -0,0 +1,312 @@
+/**
+ * Linear Webhook Integration
+ *
+ * Handles webhooks from Linear to automatically create tasks when:
+ * - Issues are created with specific labels
+ * - Issues are updated with AI-task label
+ * - Issues have specific commands in comments
+ */
+import { createHmac, timingSafeEqual } from 'crypto';
+import { logger } from '../utils/logger.js';
+/**
+ * Verify Linear webhook signature
+ */
+function verifyLinearSignature(rawBody, signature) {
+    const secret = process.env.LINEAR_WEBHOOK_SECRET;
+    if (!secret) {
+        logger.warn('LINEAR_WEBHOOK_SECRET not configured');
+        return false;
+    }
+    try {
+        // Compute HMAC-SHA256 signature
+        const expectedSignature = createHmac('sha256', secret)
+            .update(rawBody)
+            .digest('hex');
+        // Timing-safe comparison
+        const signatureBuffer = Buffer.from(signature);
+        const expectedBuffer = Buffer.from(expectedSignature);
+        if (signatureBuffer.length !== expectedBuffer.length) {
+            return false;
+        }
+        return timingSafeEqual(signatureBuffer, expectedBuffer);
+    }
+    catch (error) {
+        logger.error('Linear signature verification failed', error);
+        return false;
+    }
+}
+/**
+ * Verify webhook timestamp to prevent replay attacks
+ */
+function verifyTimestamp(webhookTimestamp) {
+    const now = Date.now();
+    const diff = Math.abs(now - webhookTimestamp);
+    const maxAge = 5 * 60 * 1000; // 5 minutes
+    if (diff > maxAge) {
+        logger.warn('Linear webhook timestamp too old', {
+            webhookTimestamp,
+            currentTime: now,
+            diffMs: diff,
+        });
+        return false;
+    }
+    return true;
+}
+/**
+ * Map Linear priority to task priority
+ */
+function mapLinearPriority(linearPriority) {
+    switch (linearPriority) {
+        case 4: // Urgent
+            return 'critical';
+        case 3: // High
+            return 'high';
+        case 2: // Medium
+            return 'medium';
+        case 1: // Low
+        case 0: // No priority
+        default:
+            return 'low';
+    }
+}
+/**
+ * Get task priority from Linear labels
+ */
+function getPriorityFromLabels(labels) {
+    if (!labels || labels.length === 0)
+        return undefined;
+    const labelNames = labels.map((l) => l.name.toLowerCase());
+    if (labelNames.some((name) => name.includes('critical') || name.includes('urgent'))) {
+        return 'critical';
+    }
+    if (labelNames.some((name) => name.includes('high') || name.includes('priority'))) {
+        return 'high';
+    }
+    if (labelNames.some((name) => name.includes('medium'))) {
+        return 'medium';
+    }
+    if (labelNames.some((name) => name.includes('low'))) {
+        return 'low';
+    }
+    return undefined;
+}
+/**
+ * Check if issue should trigger AI task
+ */
+function shouldCreateTask(issue) {
+    const aiTaskLabel = process.env.LINEAR_AI_TASK_LABEL || 'ai-task';
+    if (!issue.labels)
+        return false;
+    return issue.labels.some((label) => label.name.toLowerCase() === aiTaskLabel.toLowerCase());
+}
+/**
+ * Build prompt from issue
+ */
+function buildPromptFromIssue(issue) {
+    let prompt = `# Linear Issue: ${issue.identifier} - ${issue.title}\n\n`;
+    if (issue.description) {
+        prompt += `## Description\n${issue.description}\n\n`;
+    }
+    if (issue.labels && issue.labels.length > 0) {
+        prompt += `## Labels\n${issue.labels.map((l) => l.name).join(', ')}\n\n`;
+    }
+    if (issue.project) {
+        prompt += `## Project\n${issue.project.name}\n\n`;
+    }
+    prompt += `## Team\n${issue.team.name}\n\n`;
+    prompt += `## State\n${issue.state.name}\n\n`;
+    if (issue.assignee) {
+        prompt += `## Assigned To\n${issue.assignee.name}\n\n`;
+    }
+    prompt += `## Task\nPlease analyze this issue and provide implementation guidance or create a solution.\n`;
+    return prompt;
+}
+/**
+ * Handle Linear webhook
+ */
+export async function handleLinearWebhook(c) {
+    const correlationId = c.req.header('X-Correlation-ID') || 'linear-webhook';
+    // Get raw body for signature verification
+    const rawBody = await c.req.text();
+    // Parse payload
+    let payload;
+    try {
+        payload = JSON.parse(rawBody);
+    }
+    catch (error) {
+        logger.error('Failed to parse Linear webhook payload', error, { correlationId });
+        throw new Error('Invalid JSON payload');
+    }
+    logger.info('Linear webhook received', {
+        correlationId,
+        type: payload.type,
+        action: payload.action,
+        webhookId: payload.webhookId,
+    });
+    // Verify signature
+    const signature = c.req.header('Linear-Signature');
+    if (!signature) {
+        throw new Error('Missing Linear-Signature header');
+    }
+    if (!verifyLinearSignature(rawBody, signature)) {
+        throw new Error('Invalid Linear webhook signature');
+    }
+    // Verify timestamp to prevent replay attacks
+    if (!verifyTimestamp(payload.webhookTimestamp)) {
+        throw new Error('Webhook timestamp too old');
+    }
+    // Handle different event types
+    switch (payload.type) {
+        case 'Issue':
+            return handleIssueEvent(payload, correlationId);
+        case 'Comment':
+            return handleCommentEvent(payload, correlationId);
+        case 'IssueLabel':
+            return handleIssueLabelEvent(payload, correlationId);
+        default:
+            logger.debug('Linear webhook event type not handled', {
+                correlationId,
+                type: payload.type,
+            });
+            return null;
+    }
+}
+/**
+ * Handle Issue events (create, update)
+ */
+function handleIssueEvent(payload, correlationId) {
+    const issue = payload.data;
+    logger.info('Linear issue event', {
+        correlationId,
+        action: payload.action,
+        issueId: issue.identifier,
+        title: issue.title,
+    });
+    // Only process create and update actions
+    if (payload.action !== 'create' && payload.action !== 'update') {
+        logger.debug('Linear issue action not processed', {
+            correlationId,
+            action: payload.action,
+        });
+        return null;
+    }
+    // Check if issue has AI task label
+    if (!shouldCreateTask(issue)) {
+        logger.debug('Linear issue does not have AI task label', {
+            correlationId,
+            issueId: issue.identifier,
+            labels: issue.labels?.map((l) => l.name),
+        });
+        return null;
+    }
+    // Determine priority (label-based overrides Linear priority)
+    const labelPriority = getPriorityFromLabels(issue.labels);
+    const stringPriority = labelPriority || mapLinearPriority(issue.priority);
+    // Map to numeric priority (1-4)
+    const priorityMap = {
+        critical: 1,
+        high: 2,
+        medium: 3,
+        low: 4,
+    };
+    // Create task input
+    const taskInput = {
+        title: `${issue.identifier}: ${issue.title}`,
+        description: issue.description || issue.title,
+        prompt: buildPromptFromIssue(issue),
+        priority: priorityMap[stringPriority],
+        source: 'linear_issue',
+        sourceId: issue.id,
+        sourceUrl: issue.url,
+        labels: issue.labels?.map((l) => l.name) || [],
+        metadata: {
+            identifier: issue.identifier,
+            teamKey: issue.team.key,
+            teamName: issue.team.name,
+            state: issue.state.name,
+            projectName: issue.project?.name,
+            assignee: issue.assignee?.email,
+        },
+    };
+    logger.info('Linear task created from issue', {
+        correlationId,
+        issueId: issue.identifier,
+        priority: stringPriority,
+    });
+    return taskInput;
+}
+/**
+ * Handle Comment events
+ */
+function handleCommentEvent(payload, correlationId) {
+    if (payload.action !== 'create') {
+        return null;
+    }
+    const comment = payload.data;
+    logger.info('Linear comment event', {
+        correlationId,
+        issueId: comment.issue.identifier,
+        commentId: comment.id,
+    });
+    // Check for AI command in comment (e.g., "/ai-do")
+    const aiCommandPattern = /\/ai-do\s+(.+)/i;
+    const match = comment.body.match(aiCommandPattern);
+    if (!match) {
+        logger.debug('Linear comment does not contain AI command', {
+            correlationId,
+            commentId: comment.id,
+        });
+        return null;
+    }
+    const instruction = match[1].trim();
+    // Build prompt from comment instruction
+    const prompt = `# Linear Issue: ${comment.issue.identifier} - ${comment.issue.title}\n\n`;
+    const fullPrompt = prompt +
+        (comment.issue.description ? `## Issue Description\n${comment.issue.description}\n\n` : '') +
+        `## AI Instruction\n${instruction}\n\n` +
+        `Requested by: ${comment.user.name}\n`;
+    // Map priority
+    const stringPriority = mapLinearPriority(comment.issue.priority);
+    const priorityMap = {
+        critical: 1,
+        high: 2,
+        medium: 3,
+        low: 4,
+    };
+    const taskInput = {
+        title: `${comment.issue.identifier}: ${instruction.substring(0, 100)}`,
+        description: instruction,
+        prompt: fullPrompt,
+        priority: priorityMap[stringPriority],
+        source: 'linear_comment',
+        sourceId: comment.id,
+        sourceUrl: comment.url,
+        labels: comment.issue.labels?.map((l) => l.name) || [],
+        metadata: {
+            issueId: comment.issue.id,
+            identifier: comment.issue.identifier,
+            commentUser: comment.user.email,
+        },
+    };
+    logger.info('Linear task created from comment', {
+        correlationId,
+        issueId: comment.issue.identifier,
+        commentId: comment.id,
+    });
+    return taskInput;
+}
+/**
+ * Handle IssueLabel events (label added/removed)
+ */
+function handleIssueLabelEvent(payload, correlationId) {
+    // When ai-task label is added, treat it like issue creation
+    if (payload.action === 'create') {
+        const data = payload.data;
+        // data.issue should contain the issue information
+        if (typeof data === 'object' && data !== null && 'issue' in data && data.issue) {
+            return handleIssueEvent({ ...payload, type: 'Issue', action: 'update', data: data.issue }, correlationId);
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=linear.js.map

package/dist/integrations/tailscale.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Tailscale Integration
+ *
+ * Auto-configure Tailscale Serve and Funnel for remote access to profClaw.
+ * Tailscale Serve exposes a local port to your tailnet.
+ * Tailscale Funnel exposes it to the public internet via a Tailscale-managed domain.
+ *
+ * Requirements:
+ *   - Tailscale CLI installed and authenticated (`tailscale status`)
+ *   - Tailscale Funnel requires HTTPS and ACL permissions
+ */
+export interface TailscaleStatus {
+    installed: boolean;
+    running: boolean;
+    loggedIn: boolean;
+    hostname?: string;
+    tailnetName?: string;
+    ipv4?: string;
+    ipv6?: string;
+    version?: string;
+    os?: string;
+}
+export interface TailscaleServeConfig {
+    port: number;
+    protocol: 'http' | 'https';
+    path?: string;
+    servePort?: number;
+}
+export interface TailscaleFunnelConfig extends TailscaleServeConfig {
+    funnelPort?: number;
+}
+export interface TailscaleServeResult {
+    success: boolean;
+    url?: string;
+    error?: string;
+}
+declare class TailscaleService {
+    /**
+     * Check if Tailscale is installed and get status
+     */
+    getStatus(): Promise<TailscaleStatus>;
+    /**
+     * Start Tailscale Serve - expose local port to tailnet
+     */
+    startServe(config: TailscaleServeConfig): Promise<TailscaleServeResult>;
+    /**
+     * Start Tailscale Funnel - expose to public internet
+     */
+    startFunnel(config: TailscaleFunnelConfig): Promise<TailscaleServeResult>;
+    /**
+     * Stop Tailscale Serve/Funnel for a port
+     */
+    stop(port?: number): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get current serve/funnel configuration
+     */
+    getServeConfig(): Promise<{
+        success: boolean;
+        config?: unknown;
+        error?: string;
+    }>;
+}
+export declare function getTailscaleService(): TailscaleService;
+export { TailscaleService };
+//# sourceMappingURL=tailscale.d.ts.map