@renseiai/agentfactory-server 0.8.0

package/dist/src/session-storage.js

@@ -0,0 +1,397 @@
+import { isRedisConfigured, redisSet, redisGet, redisDel, redisKeys } from './redis.js';
+const log = {
+    info: (msg, data) => console.log(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/**
+ * Key prefix for session state in KV
+ */
+const SESSION_KEY_PREFIX = 'agent:session:';
+/**
+ * Session state TTL in seconds (24 hours)
+ * Sessions older than this are automatically cleaned up by KV
+ */
+const SESSION_TTL_SECONDS = 24 * 60 * 60;
+/**
+ * Build the KV key for a session
+ */
+function buildSessionKey(linearSessionId) {
+    return `${SESSION_KEY_PREFIX}${linearSessionId}`;
+}
+/**
+ * Store agent session state in Redis
+ *
+ * @param linearSessionId - The Linear session ID from webhook
+ * @param state - The session state to store
+ */
+export async function storeSessionState(linearSessionId, state) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, session state will not be persisted');
+        const now = Math.floor(Date.now() / 1000);
+        return {
+            ...state,
+            linearSessionId,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const key = buildSessionKey(linearSessionId);
+    // Check for existing session to preserve createdAt
+    const existing = await redisGet(key);
+    const sessionState = {
+        ...state,
+        linearSessionId,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+    await redisSet(key, sessionState, SESSION_TTL_SECONDS);
+    log.info('Stored session state', {
+        linearSessionId,
+        issueId: state.issueId,
+        status: state.status,
+        hasProviderSessionId: !!state.providerSessionId,
+    });
+    return sessionState;
+}
+/**
+ * Retrieve agent session state from Redis
+ *
+ * @param linearSessionId - The Linear session ID
+ * @returns The session state or null if not found
+ */
+export async function getSessionState(linearSessionId) {
+    if (!isRedisConfigured()) {
+        log.debug('Redis not configured, cannot retrieve session state');
+        return null;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const state = await redisGet(key);
+    if (state) {
+        log.debug('Retrieved session state', {
+            linearSessionId,
+            issueId: state.issueId,
+            status: state.status,
+        });
+    }
+    return state;
+}
+/**
+ * Update the provider session ID for a session
+ * Called when the Claude init event is received with the session ID
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param providerSessionId - The Provider CLI session ID
+ */
+export async function updateProviderSessionId(linearSessionId, providerSessionId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot update provider session ID');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for provider session ID update', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        providerSessionId,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Updated provider session ID', { linearSessionId, providerSessionId });
+    return true;
+}
+/**
+ * Update session status
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param status - The new status
+ */
+export async function updateSessionStatus(linearSessionId, status) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot update session status');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for status update', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Updated session status', { linearSessionId, status });
+    return true;
+}
+/**
+ * Update session cost data (tokens and USD)
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param costData - Cost fields to persist
+ */
+export async function updateSessionCostData(linearSessionId, costData) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot update session cost data');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for cost update', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        totalCostUsd: costData.totalCostUsd ?? existing.totalCostUsd,
+        inputTokens: costData.inputTokens ?? existing.inputTokens,
+        outputTokens: costData.outputTokens ?? existing.outputTokens,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Updated session cost data', {
+        linearSessionId,
+        totalCostUsd: updated.totalCostUsd,
+    });
+    return true;
+}
+/**
+ * Reset a session for re-queuing after orphan cleanup
+ * Clears workerId and resets status to pending so a new worker can claim it
+ *
+ * @param linearSessionId - The Linear session ID
+ */
+export async function resetSessionForRequeue(linearSessionId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot reset session');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for reset', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'pending',
+        workerId: undefined, // Clear workerId so new worker can claim
+        claimedAt: undefined,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Reset session for requeue', {
+        linearSessionId,
+        previousWorkerId: existing.workerId,
+    });
+    return true;
+}
+/**
+ * Delete session state from KV
+ *
+ * @param linearSessionId - The Linear session ID
+ * @returns Whether the deletion was successful
+ */
+export async function deleteSessionState(linearSessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const result = await redisDel(key);
+    log.info('Deleted session state', { linearSessionId });
+    return result > 0;
+}
+/**
+ * Get session state by issue ID
+ * Useful when we have the issue but not the session ID
+ *
+ * When multiple sessions exist for the same issue (e.g., one running + several
+ * failed), this function returns the most relevant one — preferring active
+ * sessions (running/claimed/pending) over inactive ones. Without this
+ * prioritization, an arbitrary first-match could hide a running session behind
+ * a failed one, causing the governor to re-dispatch work for an issue that
+ * already has an agent in-flight.
+ *
+ * @param issueId - The Linear issue ID
+ * @returns The most relevant session state for this issue or null
+ */
+export async function getSessionStateByIssue(issueId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    // Scan for sessions with this issue ID
+    // Note: This is less efficient than direct lookup, use sparingly
+    const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
+    const activeStatuses = ['running', 'claimed', 'pending'];
+    let fallback = null;
+    for (const key of keys) {
+        const state = await redisGet(key);
+        if (state?.issueId === issueId) {
+            // Prefer active sessions — return immediately if found
+            if (activeStatuses.includes(state.status)) {
+                return state;
+            }
+            // Keep first non-active match as fallback
+            if (!fallback) {
+                fallback = state;
+            }
+        }
+    }
+    return fallback;
+}
+// ============================================
+// Worker Pool Operations
+// ============================================
+/**
+ * Mark a session as claimed by a worker
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param workerId - The worker claiming the session
+ */
+export async function claimSession(linearSessionId, workerId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for claim', { linearSessionId });
+        return false;
+    }
+    if (existing.status !== 'pending') {
+        log.warn('Session not in pending status', {
+            linearSessionId,
+            status: existing.status,
+        });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'claimed',
+        workerId,
+        claimedAt: now,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session claimed', { linearSessionId, workerId });
+    return true;
+}
+/**
+ * Update session with worker info when work starts
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param workerId - The worker processing the session
+ * @param worktreePath - Path to the git worktree
+ */
+export async function startSession(linearSessionId, workerId, worktreePath) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for start', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'running',
+        workerId,
+        worktreePath,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session started', { linearSessionId, workerId, worktreePath });
+    return true;
+}
+/**
+ * Get all sessions from Redis
+ * For dashboard display
+ */
+export async function getAllSessions() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
+        const sessions = [];
+        for (const key of keys) {
+            const state = await redisGet(key);
+            if (state) {
+                sessions.push(state);
+            }
+        }
+        // Sort by updatedAt descending (most recent first)
+        sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        return sessions;
+    }
+    catch (error) {
+        log.error('Failed to get all sessions', { error });
+        return [];
+    }
+}
+/**
+ * Get sessions by status
+ */
+export async function getSessionsByStatus(status) {
+    const allSessions = await getAllSessions();
+    const statusArray = Array.isArray(status) ? status : [status];
+    return allSessions.filter((s) => statusArray.includes(s.status));
+}
+/**
+ * Transfer session ownership to a new worker
+ * Used when a worker re-registers after disconnection and gets a new ID
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param newWorkerId - The new worker ID to assign
+ * @param oldWorkerId - The previous worker ID (for validation)
+ * @returns Whether the transfer was successful
+ */
+export async function transferSessionOwnership(linearSessionId, newWorkerId, oldWorkerId) {
+    if (!isRedisConfigured()) {
+        return { transferred: false, reason: 'Redis not configured' };
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        return { transferred: false, reason: 'Session not found' };
+    }
+    // Validate that the old worker ID matches (security check)
+    if (existing.workerId && existing.workerId !== oldWorkerId) {
+        log.warn('Session ownership transfer rejected - worker ID mismatch', {
+            linearSessionId,
+            expectedWorkerId: oldWorkerId,
+            actualWorkerId: existing.workerId,
+        });
+        return {
+            transferred: false,
+            reason: `Session owned by different worker: ${existing.workerId}`,
+        };
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        workerId: newWorkerId,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session ownership transferred', {
+        linearSessionId,
+        oldWorkerId,
+        newWorkerId,
+    });
+    return { transferred: true };
+}

package/dist/src/token-storage.d.ts

@@ -0,0 +1,118 @@
+/**
+ * OAuth Token Storage Module
+ *
+ * Manages Linear OAuth token lifecycle in Redis:
+ * - Store, retrieve, refresh, and revoke tokens
+ * - Automatic token refresh before expiration
+ * - Multi-workspace token support
+ */
+/**
+ * OAuth token data stored in Redis
+ */
+export interface StoredToken {
+    /** The OAuth access token for API calls */
+    accessToken: string;
+    /** The refresh token for obtaining new access tokens */
+    refreshToken?: string;
+    /** Token type (usually "Bearer") */
+    tokenType: string;
+    /** OAuth scopes granted */
+    scope?: string;
+    /** Unix timestamp when the token expires */
+    expiresAt?: number;
+    /** Unix timestamp when the token was stored */
+    storedAt: number;
+    /** Workspace/organization ID this token belongs to */
+    workspaceId: string;
+    /** Workspace name for display purposes */
+    workspaceName?: string;
+}
+/**
+ * Response from Linear OAuth token exchange
+ */
+export interface LinearTokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    token_type: string;
+    expires_in?: number;
+    scope?: string;
+}
+/**
+ * Organization info from Linear API
+ */
+export interface LinearOrganization {
+    id: string;
+    name: string;
+    urlKey: string;
+}
+/**
+ * Store OAuth token for a workspace in Redis
+ *
+ * @param workspaceId - The Linear organization ID
+ * @param tokenResponse - The token data from OAuth exchange
+ * @param workspaceName - Optional workspace name for display
+ */
+export declare function storeToken(workspaceId: string, tokenResponse: LinearTokenResponse, workspaceName?: string): Promise<StoredToken>;
+/**
+ * Retrieve OAuth token for a workspace from Redis
+ *
+ * @param workspaceId - The Linear organization ID
+ * @returns The stored token or null if not found
+ */
+export declare function getToken(workspaceId: string): Promise<StoredToken | null>;
+/**
+ * Check if a token needs to be refreshed
+ * Returns true if token expires within the buffer period
+ *
+ * @param token - The stored token to check
+ * @returns Whether the token should be refreshed
+ */
+export declare function shouldRefreshToken(token: StoredToken): boolean;
+/**
+ * Refresh an OAuth token using the refresh token
+ *
+ * @param token - The current stored token with refresh token
+ * @param clientId - The Linear OAuth client ID
+ * @param clientSecret - The Linear OAuth client secret
+ * @returns The new stored token or null if refresh failed
+ */
+export declare function refreshToken(token: StoredToken, clientId: string, clientSecret: string): Promise<StoredToken | null>;
+/**
+ * Get a valid access token for a workspace, refreshing if necessary
+ *
+ * @param workspaceId - The Linear organization ID
+ * @param clientId - Optional OAuth client ID for refresh (defaults to env var)
+ * @param clientSecret - Optional OAuth client secret for refresh (defaults to env var)
+ * @returns The access token or null if not available
+ */
+export declare function getAccessToken(workspaceId: string, clientId?: string, clientSecret?: string): Promise<string | null>;
+/**
+ * Delete a token from Redis (for cleanup or revocation)
+ *
+ * @param workspaceId - The Linear organization ID
+ * @returns Whether the deletion was successful
+ */
+export declare function deleteToken(workspaceId: string): Promise<boolean>;
+/**
+ * List all stored workspace tokens (for admin purposes)
+ * Note: This scans all keys with the token prefix
+ *
+ * @returns Array of workspace IDs with stored tokens
+ */
+export declare function listStoredWorkspaces(): Promise<string[]>;
+/**
+ * Clean up expired tokens from Redis storage
+ * Should be called periodically (e.g., via cron job)
+ *
+ * @returns Number of tokens cleaned up
+ */
+export declare function cleanupExpiredTokens(): Promise<number>;
+/**
+ * Fetch the current user's organization from Linear API
+ * Used after OAuth to determine which workspace the token belongs to
+ *
+ * @param accessToken - The OAuth access token
+ * @returns Organization info or null if fetch failed
+ */
+export declare function fetchOrganization(accessToken: string): Promise<LinearOrganization | null>;
+//# sourceMappingURL=token-storage.d.ts.map

package/dist/src/token-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-storage.d.ts","sourceRoot":"","sources":["../../src/token-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,0CAA0C;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf;AAoBD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,mBAAmB,EAClC,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,WAAW,CAAC,CAsBtB;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAU/E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAU9D;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAgD7B;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BxB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYvE;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ9D;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAsB5D;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA6CpC"}