@pollit/twin-dev-bot 0.0.1

package/dist/claude/session-manager.js

@@ -0,0 +1,247 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { createLogger } from "../core/logger.js";
+import { SESSIONS_FILE } from "../core/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/claude-runner.d.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from "events";
+export interface ClaudeRunnerOptions {
+    directory: string;
+    prompt: string;
+    sessionId?: string;
+}
+export interface AskUserQuestionInput {
+    questions: Array<{
+        question: string;
+        header?: string;
+        options: Array<{
+            label: string;
+            description?: string;
+        }>;
+        multiSelect?: boolean;
+    }>;
+}
+export interface AskUserEvent {
+    input: AskUserQuestionInput;
+}
+export interface InitEvent {
+    sessionId: string;
+    model?: string;
+}
+export interface TextEvent {
+    text: string;
+}
+export interface ToolUseEvent {
+    toolName: string;
+    input: Record<string, unknown>;
+}
+export interface ResultEvent {
+    result?: string;
+    costUsd?: number;
+}
+export declare class ClaudeRunner extends EventEmitter {
+    private options;
+    private sessionId;
+    private process;
+    /** 이미 처리한 tool_use ID를 추적 */
+    private processedToolUseIds;
+    /** init 이벤트 발생 여부 */
+    private initEmitted;
+    /** result 이벤트 발생 여부 */
+    private resultEmitted;
+    /** stderr 출력 누적 버퍼 */
+    private stderrLines;
+    constructor(options: ClaudeRunnerOptions);
+    get currentSessionId(): string | null;
+    /** 누적된 stderr 출력을 반환 */
+    get stderrOutput(): string;
+    run(): void;
+    private handleLine;
+    private handleEvent;
+    kill(): void;
+}
+export declare function runClaude(options: ClaudeRunnerOptions): ClaudeRunner;

package/dist/claude-runner.js

@@ -0,0 +1,210 @@
+import { spawn, execSync } from "child_process";
+import { EventEmitter } from "events";
+import { createLogger } from "./logger.js";
+const log = createLogger("claude-runner");
+export class ClaudeRunner extends EventEmitter {
+    options;
+    sessionId = null;
+    process = null;
+    // 중복 방지용 상태
+    /** 이미 처리한 tool_use ID를 추적 */
+    processedToolUseIds = new Set();
+    /** init 이벤트 발생 여부 */
+    initEmitted = false;
+    /** result 이벤트 발생 여부 */
+    resultEmitted = false;
+    /** stderr 출력 누적 버퍼 */
+    stderrLines = [];
+    constructor(options) {
+        super();
+        this.options = options;
+        this.sessionId = options.sessionId || null;
+    }
+    get currentSessionId() {
+        return this.sessionId;
+    }
+    /** 누적된 stderr 출력을 반환 */
+    get stderrOutput() {
+        return this.stderrLines.join("").trim();
+    }
+    run() {
+        const args = [
+            "-p", this.options.prompt,
+            "--output-format", "stream-json",
+            "--verbose",
+            "--dangerously-skip-permissions",
+        ];
+        // 세션 ID가 있으면 --resume 추가
+        if (this.options.sessionId) {
+            args.unshift("--resume", this.options.sessionId);
+        }
+        log.info("Running Claude", {
+            directory: this.options.directory,
+            prompt: this.options.prompt,
+            sessionId: this.options.sessionId || "new",
+        });
+        this.process = spawn("claude", args, {
+            cwd: this.options.directory,
+            stdio: ["ignore", "pipe", "pipe"], // stdin은 ignore로 설정 (pipe로 하면 Claude가 입력 대기 상태가 됨)
+            shell: process.platform === "win32", // Windows에서 .cmd/.exe PATH 해석에 필요
+        });
+        let buffer = "";
+        this.process.stdout?.on("data", (data) => {
+            const chunk = data.toString();
+            buffer += chunk;
+            // 줄 단위로 파싱
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    this.handleLine(trimmed);
+                }
+            }
+        });
+        this.process.stderr?.on("data", (data) => {
+            const text = data.toString();
+            log.debug("Claude stderr", { text });
+            this.stderrLines.push(text);
+        });
+        this.process.on("error", (err) => {
+            log.error("Claude process error", { error: err.message });
+            this.emit("error", err);
+        });
+        this.process.on("exit", (code) => {
+            log.info("Claude process exited", { code });
+            // 남은 버퍼 처리
+            if (buffer.trim()) {
+                this.handleLine(buffer.trim());
+            }
+            this.emit("exit", code);
+        });
+    }
+    handleLine(line) {
+        log.debug("Claude output", { line });
+        try {
+            const event = JSON.parse(line);
+            this.handleEvent(event);
+        }
+        catch {
+            // Non-JSON output from Claude CLI (e.g., progress messages)
+            log.debug("Non-JSON line from Claude (ignored)", { line: line.slice(0, 200) });
+        }
+    }
+    handleEvent(event) {
+        log.debug("Claude event", { type: event.type });
+        switch (event.type) {
+            case "system":
+                if ("subtype" in event && event.subtype === "init") {
+                    // 중복 init 방지
+                    if (this.initEmitted) {
+                        log.debug("Skipping duplicate init event");
+                        break;
+                    }
+                    this.initEmitted = true;
+                    const initEvent = event;
+                    this.sessionId = initEvent.session_id;
+                    this.emit("init", {
+                        sessionId: initEvent.session_id,
+                        model: initEvent.model,
+                    });
+                }
+                break;
+            case "assistant":
+                const msg = event.message;
+                if (msg?.content) {
+                    for (const block of msg.content) {
+                        if (block.type === "text" && block.text) {
+                            this.emit("text", { text: block.text });
+                        }
+                        else if (block.type === "tool_use" && block.name) {
+                            // tool_use 블록 수신 시 전체 구조를 로그로 기록 (문제 진단용)
+                            log.debug("tool_use block received", {
+                                id: block.id,
+                                name: block.name,
+                                hasId: !!block.id,
+                                blockKeys: Object.keys(block),
+                            });
+                            // 중복 tool_use 필터링 (id가 있는 경우)
+                            const toolUseId = block.id;
+                            if (toolUseId && this.processedToolUseIds.has(toolUseId)) {
+                                log.info("Skipping duplicate tool_use", { toolUseId, toolName: block.name });
+                                continue;
+                            }
+                            if (toolUseId) {
+                                this.processedToolUseIds.add(toolUseId);
+                            }
+                            const toolEvent = {
+                                toolName: block.name,
+                                input: block.input || {},
+                            };
+                            this.emit("toolUse", toolEvent);
+                            // AskUserQuestion 처리 흐름:
+                            // ─────────────────────────────────────────────────────────────
+                            // 1. Claude CLI가 AskUserQuestion tool_use를 출력
+                            // 2. 여기서 "askUser" 이벤트를 emit
+                            // 3. claude-runner-setup.ts의 핸들러가 Slack 스레드로 질문 블록 전송
+                            // 4. Slack 전송 완료 후 runner.kill()을 호출하여 프로세스를 종료
+                            //    - stdin이 "ignore"라서 Claude CLI가 응답을 받을 수 없음
+                            //    - 종료하지 않으면 Claude가 에러를 받고 같은 질문을 반복함
+                            // 5. 사용자가 Slack에서 버튼 클릭 또는 직접 입력으로 응답
+                            // 6. question-handlers.ts에서 --resume으로 새 프로세스를 시작
+                            // ─────────────────────────────────────────────────────────────
+                            if (block.name === "AskUserQuestion") {
+                                this.emit("askUser", {
+                                    input: block.input,
+                                });
+                            }
+                            // ExitPlanMode 처리:
+                            // stdin이 "ignore"라 CLI가 사용자 승인을 받을 수 없어 실패함.
+                            // askUser와 동일한 패턴으로 프로세스 kill → resume으로 처리.
+                            if (block.name === "ExitPlanMode") {
+                                this.emit("exitPlanMode", {});
+                            }
+                        }
+                    }
+                }
+                break;
+            case "result":
+                // 중복 result 방지
+                if (this.resultEmitted) {
+                    log.debug("Skipping duplicate result event");
+                    break;
+                }
+                this.resultEmitted = true;
+                const resultEvent = event;
+                this.emit("result", {
+                    result: resultEvent.result,
+                    costUsd: resultEvent.total_cost_usd,
+                });
+                break;
+        }
+    }
+    kill() {
+        if (this.process) {
+            if (process.platform === "win32" && this.process.pid) {
+                // Windows에서 shell: true 사용 시 프로세스 트리 전체를 종료해야 함
+                try {
+                    execSync(`taskkill /pid ${this.process.pid} /T /F`, { stdio: "ignore" });
+                }
+                catch {
+                    this.process.kill();
+                }
+            }
+            else {
+                try {
+                    this.process.kill();
+                }
+                catch {
+                    // Process already exited - ignore ESRCH
+                }
+            }
+            this.process = null;
+        }
+    }
+}
+export function runClaude(options) {
+    const runner = new ClaudeRunner(options);
+    runner.run();
+    return runner;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};