@pollit/twin-dev-bot 0.0.1 → 0.0.3

package/dist/session-manager.js

@@ -1,247 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
-import { createLogger } from "./logger.js";
-import { SESSIONS_FILE } from "./paths.js";
-const log = createLogger("session-manager");
-/**
- * 세션 키 생성: projectName:threadTs
- */
-function makeSessionKey(projectName, threadTs) {
-    return `${projectName}:${threadTs}`;
-}
-class SessionManager {
-    sessions = new Map();
-    // sessionKey (projectName:threadTs) -> sessionId 매핑
-    sessionKeyToId = new Map();
-    // threadTs -> sessionId 매핑 (스레드로 세션 찾기)
-    threadToSession = new Map();
-    loaded = false;
-    cleanupInterval = null;
-    // 24시간 동안 활동이 없는 세션은 자동 삭제
-    static MAX_INACTIVE_MS = 24 * 60 * 60 * 1000;
-    /**
-     * 파일 로드를 지연 실행. 첫 접근 시 한 번만 호출됨.
-     */
-    ensureLoaded() {
-        if (this.loaded)
-            return;
-        this.loaded = true;
-        this.loadFromFile();
-        this.startCleanupTimer();
-    }
-    /**
-     * 파일에서 세션 로드
-     */
-    loadFromFile() {
-        try {
-            if (!existsSync(SESSIONS_FILE)) {
-                log.info("No sessions file found, starting fresh");
-                return;
-            }
-            const content = readFileSync(SESSIONS_FILE, "utf-8");
-            let data;
-            try {
-                data = JSON.parse(content);
-            }
-            catch (parseError) {
-                log.error("Sessions file is corrupted, starting fresh", { parseError });
-                return;
-            }
-            if (!data.sessions || !Array.isArray(data.sessions)) {
-                log.error("Sessions file has invalid structure, starting fresh");
-                return;
-            }
-            let loadedCount = 0;
-            for (const s of data.sessions) {
-                try {
-                    const session = {
-                        sessionId: s.sessionId,
-                        projectName: s.projectName,
-                        directory: s.directory,
-                        slackChannelId: s.slackChannelId,
-                        slackThreadTs: s.slackThreadTs,
-                        startedAt: new Date(s.startedAt),
-                        lastActivityAt: new Date(s.lastActivityAt),
-                        autopilot: s.autopilot ?? false,
-                    };
-                    this.sessions.set(session.sessionId, session);
-                    const key = makeSessionKey(session.projectName, session.slackThreadTs);
-                    this.sessionKeyToId.set(key, session.sessionId);
-                    this.threadToSession.set(session.slackThreadTs, session.sessionId);
-                    loadedCount++;
-                }
-                catch (sessionError) {
-                    log.warn("Skipping invalid session entry", { entry: s, error: sessionError });
-                }
-            }
-            log.info("Sessions loaded from file", { count: loadedCount, total: data.sessions.length });
-        }
-        catch (error) {
-            log.error("Failed to load sessions from file", { error });
-        }
-    }
-    /**
-     * 파일에 세션 저장
-     */
-    saveToFile() {
-        try {
-            const sessions = Array.from(this.sessions.values()).map((s) => ({
-                sessionId: s.sessionId,
-                projectName: s.projectName,
-                directory: s.directory,
-                slackChannelId: s.slackChannelId,
-                slackThreadTs: s.slackThreadTs,
-                startedAt: s.startedAt.toISOString(),
-                lastActivityAt: s.lastActivityAt.toISOString(),
-                autopilot: s.autopilot ?? undefined,
-            }));
-            const data = {
-                version: 1,
-                sessions,
-            };
-            const tmpFile = SESSIONS_FILE + ".tmp";
-            writeFileSync(tmpFile, JSON.stringify(data, null, 2));
-            renameSync(tmpFile, SESSIONS_FILE);
-            log.debug("Sessions saved to file", { count: sessions.length });
-            return true;
-        }
-        catch (error) {
-            log.error("Failed to save sessions to file", { error });
-            return false;
-        }
-    }
-    add(session) {
-        this.ensureLoaded();
-        this.sessions.set(session.sessionId, session);
-        const key = makeSessionKey(session.projectName, session.slackThreadTs);
-        this.sessionKeyToId.set(key, session.sessionId);
-        this.threadToSession.set(session.slackThreadTs, session.sessionId);
-        log.info("Session added", {
-            sessionId: session.sessionId,
-            projectName: session.projectName,
-            threadTs: session.slackThreadTs,
-            sessionKey: key,
-        });
-        this.saveToFile();
-    }
-    get(sessionId) {
-        this.ensureLoaded();
-        return this.sessions.get(sessionId);
-    }
-    /**
-     * projectName과 threadTs로 세션 조회
-     */
-    getBySessionKey(projectName, threadTs) {
-        this.ensureLoaded();
-        const key = makeSessionKey(projectName, threadTs);
-        const sessionId = this.sessionKeyToId.get(key);
-        if (sessionId) {
-            return this.sessions.get(sessionId);
-        }
-        return undefined;
-    }
-    getByThread(threadTs) {
-        this.ensureLoaded();
-        const sessionId = this.threadToSession.get(threadTs);
-        if (sessionId) {
-            return this.sessions.get(sessionId);
-        }
-        return undefined;
-    }
-    updateActivity(sessionId) {
-        this.ensureLoaded();
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.lastActivityAt = new Date();
-            this.saveToFile();
-        }
-    }
-    /**
-     * threadTs로 세션의 autopilot 플래그 변경
-     */
-    setAutopilot(threadTs, value) {
-        this.ensureLoaded();
-        const sessionId = this.threadToSession.get(threadTs);
-        if (!sessionId)
-            return;
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.autopilot = value;
-            this.saveToFile();
-            log.info("Session autopilot updated", { sessionId, threadTs, autopilot: value });
-        }
-    }
-    remove(sessionId) {
-        this.ensureLoaded();
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            const key = makeSessionKey(session.projectName, session.slackThreadTs);
-            this.sessionKeyToId.delete(key);
-            this.threadToSession.delete(session.slackThreadTs);
-            this.sessions.delete(sessionId);
-            log.info("Session removed", { sessionId });
-            this.saveToFile();
-        }
-    }
-    getActiveCount() {
-        this.ensureLoaded();
-        return this.sessions.size;
-    }
-    /**
-     * 비활성 세션 정리 (lastActivityAt 기준)
-     */
-    cleanup() {
-        this.ensureLoaded();
-        const now = Date.now();
-        let cleanedCount = 0;
-        for (const [sessionId, session] of this.sessions.entries()) {
-            const inactiveMs = now - session.lastActivityAt.getTime();
-            if (inactiveMs > SessionManager.MAX_INACTIVE_MS) {
-                const key = makeSessionKey(session.projectName, session.slackThreadTs);
-                this.sessionKeyToId.delete(key);
-                this.threadToSession.delete(session.slackThreadTs);
-                this.sessions.delete(sessionId);
-                cleanedCount++;
-                log.info("Session expired due to inactivity", {
-                    sessionId,
-                    projectName: session.projectName,
-                    inactiveDays: Math.floor(inactiveMs / (24 * 60 * 60 * 1000)),
-                });
-            }
-        }
-        if (cleanedCount > 0) {
-            this.saveToFile();
-            log.info("Session cleanup completed", { cleanedCount, remaining: this.sessions.size });
-        }
-        return cleanedCount;
-    }
-    /**
-     * 주기적 정리 타이머 시작 (매 시간마다)
-     */
-    startCleanupTimer() {
-        if (this.cleanupInterval)
-            return;
-        // 매 시간마다 실행 (첫 실행은 1시간 후)
-        this.cleanupInterval = setInterval(() => {
-            this.cleanup();
-        }, 60 * 60 * 1000);
-        this.cleanupInterval.unref();
-        log.debug("Session cleanup timer started (runs every hour)");
-    }
-    /**
-     * 정리 타이머 중지 (주로 테스트용)
-     */
-    stopCleanupTimer() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-            log.debug("Session cleanup timer stopped");
-        }
-    }
-    /**
-     * 테스트용: cleanup 수동 실행
-     */
-    runCleanup() {
-        return this.cleanup();
-    }
-}
-export const sessionManager = new SessionManager();

package/dist/workspace-store.d.ts

@@ -1,27 +0,0 @@
-/**
- * Workspace Store
- *
- * /twindevbot goto 로 생성된 스레드와 작업 디렉토리의 매핑을 관리합니다.
- * 스레드에 첫 메시지가 오면 이 매핑을 사용하여 Claude 세션을 시작합니다.
- *
- * 키: threadTs (Slack 스레드 부모 메시지 타임스탬프)
- * 값: { directory, projectName, channelId }
- */
-export interface Workspace {
-    directory: string;
-    projectName: string;
-    channelId: string;
-    autopilot?: boolean;
-    createdAt?: Date;
-}
-export declare function addWorkspace(threadTs: string, workspace: Workspace): void;
-export declare function getWorkspace(threadTs: string): Workspace | undefined;
-export declare function removeWorkspace(threadTs: string): void;
-/**
- * 정리 타이머 중지 (주로 테스트용)
- */
-export declare function stopCleanupTimer(): void;
-/**
- * 테스트용: cleanup 수동 실행
- */
-export declare function runCleanup(): number;

package/dist/workspace-store.js

@@ -1,160 +0,0 @@
-/**
- * Workspace Store
- *
- * /twindevbot goto 로 생성된 스레드와 작업 디렉토리의 매핑을 관리합니다.
- * 스레드에 첫 메시지가 오면 이 매핑을 사용하여 Claude 세션을 시작합니다.
- *
- * 키: threadTs (Slack 스레드 부모 메시지 타임스탬프)
- * 값: { directory, projectName, channelId }
- */
-import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
-import { createLogger } from "./logger.js";
-import { WORKSPACES_FILE } from "./paths.js";
-const log = createLogger("workspace-store");
-const workspaces = new Map();
-let cleanupInterval = null;
-// 24시간이 지난 워크스페이스는 자동 삭제
-const MAX_AGE_MS = 24 * 60 * 60 * 1000;
-function loadFromFile() {
-    try {
-        if (!existsSync(WORKSPACES_FILE)) {
-            log.info("No workspaces file found, starting fresh");
-            return;
-        }
-        const content = readFileSync(WORKSPACES_FILE, "utf-8");
-        let data;
-        try {
-            data = JSON.parse(content);
-        }
-        catch (parseError) {
-            log.error("Workspaces file is corrupted, starting fresh", { parseError });
-            return;
-        }
-        if (!data.workspaces || !Array.isArray(data.workspaces)) {
-            log.error("Workspaces file has invalid structure, starting fresh");
-            return;
-        }
-        let loadedCount = 0;
-        for (const w of data.workspaces) {
-            try {
-                workspaces.set(w.threadTs, {
-                    directory: w.directory,
-                    projectName: w.projectName,
-                    channelId: w.channelId,
-                    autopilot: w.autopilot,
-                    createdAt: w.createdAt ? new Date(w.createdAt) : new Date(),
-                });
-                loadedCount++;
-            }
-            catch (entryError) {
-                log.warn("Skipping invalid workspace entry", { entry: w, error: entryError });
-            }
-        }
-        log.info("Workspaces loaded from file", { count: loadedCount, total: data.workspaces.length });
-    }
-    catch (error) {
-        log.error("Failed to load workspaces from file", { error });
-    }
-}
-function saveToFile() {
-    try {
-        const serialized = Array.from(workspaces.entries()).map(([threadTs, w]) => ({
-            threadTs,
-            directory: w.directory,
-            projectName: w.projectName,
-            channelId: w.channelId,
-            autopilot: w.autopilot ?? undefined,
-            createdAt: w.createdAt?.toISOString(),
-        }));
-        const data = {
-            version: 1,
-            workspaces: serialized,
-        };
-        const tmpFile = WORKSPACES_FILE + ".tmp";
-        writeFileSync(tmpFile, JSON.stringify(data, null, 2));
-        renameSync(tmpFile, WORKSPACES_FILE);
-        log.debug("Workspaces saved to file", { count: serialized.length });
-    }
-    catch (error) {
-        log.error("Failed to save workspaces to file", { error });
-    }
-}
-// 모듈 로드 시 파일에서 복원
-loadFromFile();
-// 정리 타이머 시작
-function startCleanupTimer() {
-    if (cleanupInterval)
-        return;
-    // 매 시간마다 실행 (첫 실행은 1시간 후)
-    cleanupInterval = setInterval(() => {
-        cleanup();
-    }, 60 * 60 * 1000);
-    cleanupInterval.unref();
-    log.debug("Workspace cleanup timer started (runs every hour)");
-}
-startCleanupTimer();
-export function addWorkspace(threadTs, workspace) {
-    // createdAt이 없으면 현재 시간으로 설정
-    if (!workspace.createdAt) {
-        workspace.createdAt = new Date();
-    }
-    workspaces.set(threadTs, workspace);
-    log.info("Workspace registered", {
-        threadTs,
-        projectName: workspace.projectName,
-        directory: workspace.directory,
-    });
-    saveToFile();
-}
-export function getWorkspace(threadTs) {
-    return workspaces.get(threadTs);
-}
-export function removeWorkspace(threadTs) {
-    workspaces.delete(threadTs);
-    log.debug("Workspace removed", { threadTs });
-    saveToFile();
-}
-/**
- * 오래된 워크스페이스 정리 (createdAt 기준)
- */
-function cleanup() {
-    const now = Date.now();
-    let cleanedCount = 0;
-    for (const [threadTs, workspace] of workspaces.entries()) {
-        // createdAt이 없는 항목은 건너뜀 (레거시 데이터)
-        if (!workspace.createdAt) {
-            continue;
-        }
-        const ageMs = now - workspace.createdAt.getTime();
-        if (ageMs > MAX_AGE_MS) {
-            workspaces.delete(threadTs);
-            cleanedCount++;
-            log.info("Workspace expired", {
-                threadTs,
-                projectName: workspace.projectName,
-                ageDays: Math.floor(ageMs / (24 * 60 * 60 * 1000)),
-            });
-        }
-    }
-    if (cleanedCount > 0) {
-        saveToFile();
-        log.info("Workspace cleanup completed", { cleanedCount, remaining: workspaces.size });
-    }
-    return cleanedCount;
-}
-/**
- * 정리 타이머 중지 (주로 테스트용)
- */
-export function stopCleanupTimer() {
-    if (cleanupInterval) {
-        clearInterval(cleanupInterval);
-        cleanupInterval = null;
-        log.debug("Workspace cleanup timer stopped");
-    }
-}
-/**
- * 테스트용: cleanup 수동 실행
- */
-export function runCleanup() {
-    return cleanup();
-}