@pollit/twin-dev-bot 0.0.1

package/dist/channel-store.js

@@ -0,0 +1,91 @@
+/**
+ * Channel Store
+ *
+ * 슬랙 채널과 작업 디렉토리의 매핑을 관리합니다.
+ * /twindevbot init으로 설정된 채널별 작업 디렉토리를 영속적으로 저장합니다.
+ *
+ * 키: channelId (Slack 채널 ID)
+ * 값: { directory, projectName }
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { createLogger } from "./logger.js";
+import { CHANNELS_FILE } from "./paths.js";
+const log = createLogger("channel-store");
+const channels = new Map();
+function loadFromFile() {
+    try {
+        if (!existsSync(CHANNELS_FILE)) {
+            log.info("No channels file found, starting fresh");
+            return;
+        }
+        const content = readFileSync(CHANNELS_FILE, "utf-8");
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch (parseError) {
+            log.error("Channels file is corrupted, starting fresh", { parseError });
+            return;
+        }
+        if (!data.channels || !Array.isArray(data.channels)) {
+            log.error("Channels file has invalid structure, starting fresh");
+            return;
+        }
+        let loadedCount = 0;
+        for (const c of data.channels) {
+            try {
+                channels.set(c.channelId, {
+                    directory: c.directory,
+                    projectName: c.projectName,
+                });
+                loadedCount++;
+            }
+            catch (entryError) {
+                log.warn("Skipping invalid channel entry", { entry: c, error: entryError });
+            }
+        }
+        log.info("Channels loaded from file", { count: loadedCount, total: data.channels.length });
+    }
+    catch (error) {
+        log.error("Failed to load channels from file", { error });
+    }
+}
+function saveToFile() {
+    try {
+        const serialized = Array.from(channels.entries()).map(([channelId, c]) => ({
+            channelId,
+            directory: c.directory,
+            projectName: c.projectName,
+        }));
+        const data = {
+            version: 1,
+            channels: serialized,
+        };
+        const tmpFile = CHANNELS_FILE + ".tmp";
+        writeFileSync(tmpFile, JSON.stringify(data, null, 2));
+        renameSync(tmpFile, CHANNELS_FILE);
+        log.debug("Channels saved to file", { count: serialized.length });
+    }
+    catch (error) {
+        log.error("Failed to save channels to file", { error });
+    }
+}
+// 모듈 로드 시 파일에서 복원
+loadFromFile();
+export function setChannelDir(channelId, dir) {
+    channels.set(channelId, dir);
+    log.info("Channel directory set", {
+        channelId,
+        projectName: dir.projectName,
+        directory: dir.directory,
+    });
+    saveToFile();
+}
+export function getChannelDir(channelId) {
+    return channels.get(channelId);
+}
+export function removeChannelDir(channelId) {
+    channels.delete(channelId);
+    log.debug("Channel directory removed", { channelId });
+    saveToFile();
+}

package/dist/claude/active-runners.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 활성 러너 레지스트리
+ *
+ * Slack 스레드(threadTs)별로 실행 중인 ClaudeRunner 인스턴스를 추적하여
+ * 동일 스레드에서 여러 Claude 프로세스가 동시에 실행되는 것을 방지합니다.
+ *
+ * - 마지막 이벤트 수신 후 config.inactivityTimeoutMs(기본 30분) 동안
+ *   활동이 없으면 프로세스를 자동 종료하고 스레드 잠금을 해제합니다.
+ * - onTimeout 콜백을 통해 Slack 타임아웃 알림 등 외부 처리가 가능합니다.
+ */
+import type { ClaudeRunner } from "./claude-runner.js";
+export interface RegisterRunnerOptions {
+    /** 타임아웃 시 호출할 콜백 (Slack 알림 등) */
+    onTimeout?: () => void;
+}
+/**
+ * 러너를 활성 상태로 등록
+ */
+export declare function registerRunner(threadTs: string, runner: ClaudeRunner, options?: RegisterRunnerOptions): void;
+/**
+ * 이벤트 수신 시 활동 시간 갱신 및 타임아웃 리셋
+ * 저장된 runner와 동일한 인스턴스인 경우에만 갱신 (stale 갱신 방지)
+ */
+export declare function refreshActivity(threadTs: string, runner: ClaudeRunner): void;
+/**
+ * 러너를 비활성 상태로 해제
+ * 저장된 runner와 동일한 인스턴스인 경우에만 해제 (stale 해제 방지)
+ */
+export declare function unregisterRunner(threadTs: string, runner: ClaudeRunner): void;
+/**
+ * 해당 스레드에 활성 러너가 있는지 확인
+ */
+export declare function isRunnerActive(threadTs: string): boolean;
+/**
+ * 활성 러너를 강제 종료하고 등록 해제.
+ * autopilot 개입, /twindevbot stop 명령, 일반 모드 인터럽트 등
+ * 외부 요청에 의해 실행 중인 작업을 중단할 때 사용합니다.
+ */
+export declare function killActiveRunner(threadTs: string): void;
+/**
+ * 모든 활성 러너를 강제 종료하고 등록 해제
+ * (graceful shutdown 시 고아 프로세스 방지)
+ */
+export declare function killAllRunners(): number;

package/dist/claude/active-runners.js

@@ -0,0 +1,114 @@
+/**
+ * 활성 러너 레지스트리
+ *
+ * Slack 스레드(threadTs)별로 실행 중인 ClaudeRunner 인스턴스를 추적하여
+ * 동일 스레드에서 여러 Claude 프로세스가 동시에 실행되는 것을 방지합니다.
+ *
+ * - 마지막 이벤트 수신 후 config.inactivityTimeoutMs(기본 30분) 동안
+ *   활동이 없으면 프로세스를 자동 종료하고 스레드 잠금을 해제합니다.
+ * - onTimeout 콜백을 통해 Slack 타임아웃 알림 등 외부 처리가 가능합니다.
+ */
+import { createLogger } from "../core/logger.js";
+import { config } from "../core/config.js";
+const log = createLogger("active-runners");
+const activeRunners = new Map();
+function startTimer(threadTs, entry) {
+    return setTimeout(() => {
+        log.warn("Runner inactivity timeout", {
+            threadTs,
+            inactiveMs: Date.now() - entry.lastActivityAt,
+            totalMs: Date.now() - entry.registeredAt,
+        });
+        // 콜백 실행 (Slack 알림 등)
+        try {
+            entry.onTimeout?.();
+        }
+        catch (err) {
+            log.error("onTimeout callback error", err);
+        }
+        // 프로세스 종료 및 등록 해제
+        entry.runner.kill();
+        activeRunners.delete(threadTs);
+    }, config.inactivityTimeoutMs);
+}
+/**
+ * 러너를 활성 상태로 등록
+ */
+export function registerRunner(threadTs, runner, options) {
+    // 기존 엔트리가 있으면 프로세스 종료 및 타이머 정리
+    const existing = activeRunners.get(threadTs);
+    if (existing) {
+        clearTimeout(existing.timer);
+        existing.runner.kill();
+        log.info("Previous runner killed on re-register", { threadTs });
+    }
+    const now = Date.now();
+    const entry = {
+        runner,
+        timer: null,
+        registeredAt: now,
+        lastActivityAt: now,
+        onTimeout: options?.onTimeout,
+    };
+    entry.timer = startTimer(threadTs, entry);
+    activeRunners.set(threadTs, entry);
+    log.debug("Runner registered", { threadTs });
+}
+/**
+ * 이벤트 수신 시 활동 시간 갱신 및 타임아웃 리셋
+ * 저장된 runner와 동일한 인스턴스인 경우에만 갱신 (stale 갱신 방지)
+ */
+export function refreshActivity(threadTs, runner) {
+    const entry = activeRunners.get(threadTs);
+    if (!entry || entry.runner !== runner)
+        return;
+    entry.lastActivityAt = Date.now();
+    clearTimeout(entry.timer);
+    entry.timer = startTimer(threadTs, entry);
+}
+/**
+ * 러너를 비활성 상태로 해제
+ * 저장된 runner와 동일한 인스턴스인 경우에만 해제 (stale 해제 방지)
+ */
+export function unregisterRunner(threadTs, runner) {
+    const entry = activeRunners.get(threadTs);
+    if (!entry || entry.runner !== runner)
+        return;
+    clearTimeout(entry.timer);
+    activeRunners.delete(threadTs);
+    log.debug("Runner unregistered", { threadTs });
+}
+/**
+ * 해당 스레드에 활성 러너가 있는지 확인
+ */
+export function isRunnerActive(threadTs) {
+    return activeRunners.has(threadTs);
+}
+/**
+ * 활성 러너를 강제 종료하고 등록 해제.
+ * autopilot 개입, /twindevbot stop 명령, 일반 모드 인터럽트 등
+ * 외부 요청에 의해 실행 중인 작업을 중단할 때 사용합니다.
+ */
+export function killActiveRunner(threadTs) {
+    const entry = activeRunners.get(threadTs);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    entry.runner.kill();
+    activeRunners.delete(threadTs);
+    log.info("Runner killed by external request", { threadTs });
+}
+/**
+ * 모든 활성 러너를 강제 종료하고 등록 해제
+ * (graceful shutdown 시 고아 프로세스 방지)
+ */
+export function killAllRunners() {
+    const count = activeRunners.size;
+    for (const [threadTs, entry] of activeRunners) {
+        clearTimeout(entry.timer);
+        entry.runner.kill();
+        log.info("Runner killed during shutdown", { threadTs });
+    }
+    activeRunners.clear();
+    return count;
+}

package/dist/claude/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/claude-runner.js

@@ -0,0 +1,210 @@
+import { spawn, execSync } from "child_process";
+import { EventEmitter } from "events";
+import { createLogger } from "../core/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/claude/session-manager.d.ts

@@ -0,0 +1,62 @@
+export interface ClaudeSession {
+    sessionId: string;
+    projectName: string;
+    directory: string;
+    slackChannelId: string;
+    slackThreadTs: string;
+    startedAt: Date;
+    lastActivityAt: Date;
+    autopilot: boolean;
+}
+declare class SessionManager {
+    private sessions;
+    private sessionKeyToId;
+    private threadToSession;
+    private loaded;
+    private cleanupInterval;
+    private static readonly MAX_INACTIVE_MS;
+    /**
+     * 파일 로드를 지연 실행. 첫 접근 시 한 번만 호출됨.
+     */
+    private ensureLoaded;
+    /**
+     * 파일에서 세션 로드
+     */
+    private loadFromFile;
+    /**
+     * 파일에 세션 저장
+     */
+    private saveToFile;
+    add(session: ClaudeSession): void;
+    get(sessionId: string): ClaudeSession | undefined;
+    /**
+     * projectName과 threadTs로 세션 조회
+     */
+    getBySessionKey(projectName: string, threadTs: string): ClaudeSession | undefined;
+    getByThread(threadTs: string): ClaudeSession | undefined;
+    updateActivity(sessionId: string): void;
+    /**
+     * threadTs로 세션의 autopilot 플래그 변경
+     */
+    setAutopilot(threadTs: string, value: boolean): void;
+    remove(sessionId: string): void;
+    getActiveCount(): number;
+    /**
+     * 비활성 세션 정리 (lastActivityAt 기준)
+     */
+    cleanup(): number;
+    /**
+     * 주기적 정리 타이머 시작 (매 시간마다)
+     */
+    private startCleanupTimer;
+    /**
+     * 정리 타이머 중지 (주로 테스트용)
+     */
+    stopCleanupTimer(): void;
+    /**
+     * 테스트용: cleanup 수동 실행
+     */
+    runCleanup(): number;
+}
+export declare const sessionManager: SessionManager;
+export {};