@pollit/twin-dev-bot 0.0.1

package/dist/progress-tracker.js

@@ -0,0 +1,218 @@
+import { createLogger } from "./logger.js";
+import { addReaction, removeReaction, postThreadMessage, } from "./utils/slack-message.js";
+import { withRetry } from "./utils/slack-rate-limit.js";
+import { t } from "./i18n/index.js";
+const log = createLogger("progress-tracker");
+export class ProgressTracker {
+    client;
+    channelId;
+    threadTs;
+    userMessageTs;
+    statusMessageTs;
+    startTime;
+    currentReaction;
+    // updateToolUse 쓰로틀링
+    static THROTTLE_MS = 5000;
+    lastUpdateTime = 0;
+    pendingUpdate = null;
+    pendingUpdateTimer = null;
+    disposed = false;
+    constructor(options) {
+        this.client = options.client;
+        this.channelId = options.channelId;
+        this.threadTs = options.threadTs;
+        this.userMessageTs = options.userMessageTs;
+        this.startTime = Date.now();
+    }
+    /** 사용자 메시지에 👀 리액션 추가 (접수 확인) */
+    async markReceived() {
+        try {
+            await this.setReaction("eyes");
+        }
+        catch (error) {
+            log.error("Failed to mark received", error);
+        }
+    }
+    /** 작업 시작 — 👀→⚙️ 교체 + 상태 메시지 게시 */
+    async markWorking() {
+        try {
+            await this.swapReaction("eyes", "gear");
+            await this.postStatusMessage(t("progress.working"));
+        }
+        catch (error) {
+            log.error("Failed to mark working", error);
+        }
+    }
+    /** 도구 사용 — 상태 메시지 갱신 (리액션 변경 없음, 5초 쓰로틀) */
+    async updateToolUse(toolName) {
+        try {
+            const key = `progress.tool.${toolName}`;
+            const description = t(key) !== key ? t(key) : t("progress.tool.default");
+            const elapsed = this.getElapsedText();
+            const text = `:gear: ${description} (${elapsed})`;
+            const now = Date.now();
+            const timeSinceLastUpdate = now - this.lastUpdateTime;
+            if (timeSinceLastUpdate >= ProgressTracker.THROTTLE_MS) {
+                this.lastUpdateTime = now;
+                this.clearPendingUpdate();
+                await this.updateStatusMessage(text);
+            }
+            else {
+                // 쓰로틀: 마지막 텍스트로 덮어쓰고 타이머 예약
+                this.pendingUpdate = text;
+                if (!this.pendingUpdateTimer) {
+                    const delay = ProgressTracker.THROTTLE_MS - timeSinceLastUpdate;
+                    this.pendingUpdateTimer = setTimeout(() => {
+                        if (this.disposed)
+                            return;
+                        this.flushPendingUpdate().catch((err) => log.error("Failed to flush pending update", err));
+                    }, delay);
+                }
+            }
+        }
+        catch (error) {
+            log.error("Failed to update tool use", error);
+        }
+    }
+    /** 작업 완료 — ⚙️→✅ 교체 + 상태 메시지 갱신 */
+    async markCompleted() {
+        try {
+            await this.flushPendingUpdate();
+            await this.swapReaction("gear", "white_check_mark");
+            const elapsed = this.getElapsedText();
+            await this.updateStatusMessage(t("progress.completed", { elapsed }));
+        }
+        catch (error) {
+            log.error("Failed to mark completed", error);
+        }
+    }
+    /** 오류 — ⚙️→❌ 교체 + 상태 메시지 갱신 */
+    async markError(errorMessage) {
+        try {
+            await this.flushPendingUpdate();
+            await this.swapReaction(this.currentReaction ?? "gear", "x");
+            await this.updateStatusMessage(t("progress.error", { error: errorMessage }));
+        }
+        catch (error) {
+            log.error("Failed to mark error", error);
+        }
+    }
+    /** 계획 승인 — ⚙️→👍 교체 + 상태 메시지 갱신 (구현 시작 전 전환 상태) */
+    async markPlanApproved() {
+        try {
+            await this.flushPendingUpdate();
+            await this.swapReaction("gear", "thumbsup");
+            await this.updateStatusMessage(t("progress.planApproved"));
+        }
+        catch (error) {
+            log.error("Failed to mark plan approved", error);
+        }
+    }
+    /** Autopilot 자동 응답 후 계속 진행 — 리액션 변경 없이 상태 메시지만 갱신 */
+    async markAutopilotContinue() {
+        try {
+            await this.flushPendingUpdate();
+            const elapsed = this.getElapsedText();
+            await this.updateStatusMessage(t("progress.autopilotContinue", { elapsed }));
+        }
+        catch (error) {
+            log.error("Failed to mark autopilot continue", error);
+        }
+    }
+    /** 질문 전송 — ⚙️→✋ 교체 + 상태 메시지 갱신 */
+    async markAskUser() {
+        try {
+            await this.flushPendingUpdate();
+            await this.swapReaction("gear", "raised_hand");
+            await this.updateStatusMessage(t("progress.askUser"));
+        }
+        catch (error) {
+            log.error("Failed to mark ask user", error);
+        }
+    }
+    /** 타이머 정리 — 인스턴스를 더 이상 사용하지 않을 때 호출 */
+    dispose() {
+        this.clearPendingUpdate();
+        this.disposed = true;
+    }
+    // ─────────────────────────────────────────────────────────────────────
+    // private helpers
+    // ─────────────────────────────────────────────────────────────────────
+    async setReaction(emoji) {
+        if (!this.userMessageTs)
+            return;
+        await addReaction(this.client, this.channelId, this.userMessageTs, emoji);
+        this.currentReaction = emoji;
+    }
+    async swapReaction(from, to) {
+        if (!this.userMessageTs)
+            return;
+        // 현재 리액션이 from과 일치하면 제거
+        if (this.currentReaction === from) {
+            await removeReaction(this.client, this.channelId, this.userMessageTs, from);
+        }
+        try {
+            await addReaction(this.client, this.channelId, this.userMessageTs, to);
+            this.currentReaction = to;
+        }
+        catch (error) {
+            log.error("Failed to add reaction during swap", { from, to, error });
+            this.currentReaction = undefined;
+        }
+    }
+    async postStatusMessage(text) {
+        const result = await postThreadMessage(this.client, this.channelId, text, this.threadTs);
+        if (result.success && result.ts) {
+            this.statusMessageTs = result.ts;
+        }
+    }
+    async updateStatusMessage(text) {
+        if (!this.statusMessageTs) {
+            // 상태 메시지가 아직 없으면 새로 게시
+            await this.postStatusMessage(text);
+            return;
+        }
+        try {
+            await withRetry(() => this.client.chat.update({
+                channel: this.channelId,
+                ts: this.statusMessageTs,
+                text,
+            }));
+        }
+        catch (error) {
+            log.error("Failed to update status message", { error });
+        }
+    }
+    async flushPendingUpdate() {
+        if (this.pendingUpdateTimer) {
+            clearTimeout(this.pendingUpdateTimer);
+            this.pendingUpdateTimer = null;
+        }
+        if (this.pendingUpdate) {
+            const text = this.pendingUpdate;
+            this.pendingUpdate = null;
+            this.lastUpdateTime = Date.now();
+            await this.updateStatusMessage(text);
+        }
+    }
+    clearPendingUpdate() {
+        if (this.pendingUpdateTimer) {
+            clearTimeout(this.pendingUpdateTimer);
+            this.pendingUpdateTimer = null;
+        }
+        this.pendingUpdate = null;
+    }
+    getElapsedText() {
+        const elapsedMs = Date.now() - this.startTime;
+        const totalSeconds = Math.floor(elapsedMs / 1000);
+        if (totalSeconds < 1) {
+            return t("progress.lessThanOneSecond");
+        }
+        if (totalSeconds < 60) {
+            return t("progress.seconds", { n: totalSeconds });
+        }
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        return t("progress.minutesSeconds", { m: minutes, s: seconds });
+    }
+}

package/dist/question-blocks.d.ts

@@ -0,0 +1,27 @@
+import type { KnownBlock, ActionsBlock, SectionBlock, ContextBlock, DividerBlock, HeaderBlock } from "@slack/types";
+import type { Question } from "./types/index.js";
+type SlackBlock = KnownBlock | ActionsBlock | SectionBlock | ContextBlock | DividerBlock | HeaderBlock;
+interface BuildQuestionBlocksOptions {
+    /** 렌더링할 질문 */
+    question: Question;
+    /** 프로젝트명 */
+    projectName: string;
+    /** 질문 메시지 ID */
+    messageId: string;
+    /** 선택된 답변 (완료 시) */
+    selectedAnswer?: string;
+    /** 완료 여부 */
+    isSubmitted?: boolean;
+    /** multiSelect 시 현재 선택된 옵션 인덱스 배열 */
+    selectedOptionIndexes?: number[];
+}
+/**
+ * AskUserQuestion을 Slack Block으로 변환
+ * 단일 질문을 렌더링하고, 버튼 클릭 시 바로 Claude에 전달
+ *
+ * 주의: 버튼 value에는 짧은 필드만 포함.
+ * questionText, header, optionLabels 등은 action-payload-store에 별도 저장되어
+ * 핸들러에서 messageId로 조회함 (Slack action.value ~2,000바이트 제한 대응).
+ */
+export declare function buildQuestionBlocks(options: BuildQuestionBlocksOptions): SlackBlock[];
+export {};

package/dist/question-blocks.js

@@ -0,0 +1,235 @@
+import { t } from "./i18n/index.js";
+const SLACK_BLOCK_LIMIT = 50;
+const SLACK_BUTTON_TEXT_LIMIT = 75;
+/** 버튼 텍스트가 Slack 제한(75자)을 초과하면 말줄임표(…)를 붙여 잘린 것을 표시 */
+function truncateButtonText(text) {
+    if (text.length <= SLACK_BUTTON_TEXT_LIMIT)
+        return text;
+    return text.slice(0, SLACK_BUTTON_TEXT_LIMIT - 1) + "…";
+}
+/**
+ * AskUserQuestion을 Slack Block으로 변환
+ * 단일 질문을 렌더링하고, 버튼 클릭 시 바로 Claude에 전달
+ *
+ * 주의: 버튼 value에는 짧은 필드만 포함.
+ * questionText, header, optionLabels 등은 action-payload-store에 별도 저장되어
+ * 핸들러에서 messageId로 조회함 (Slack action.value ~2,000바이트 제한 대응).
+ */
+export function buildQuestionBlocks(options) {
+    const { question, projectName, messageId, selectedAnswer, isSubmitted = false, selectedOptionIndexes = [], } = options;
+    const blocks = [];
+    // 헤더
+    blocks.push({
+        type: "header",
+        text: {
+            type: "plain_text",
+            text: isSubmitted ? t("question.headerCompleted") : t("question.header"),
+            emoji: true,
+        },
+    });
+    // 질문 제목
+    if (question.header) {
+        blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text: `*${question.header}*` },
+        });
+    }
+    // 질문 내용
+    blocks.push({
+        type: "section",
+        text: { type: "mrkdwn", text: question.question },
+    });
+    blocks.push({ type: "divider" });
+    if (isSubmitted && selectedAnswer) {
+        // 완료 상태 - 체크 이모지와 선택된 답변 표시
+        blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text: `✅ *${selectedAnswer}*` },
+        });
+    }
+    else if (question.multiSelect) {
+        // 복수 선택 모드 - 토글 버튼 + 선택 완료 버튼
+        const selectedSet = new Set(selectedOptionIndexes);
+        if (question.options && question.options.length > 0) {
+            // Slack 블록 50개 제한 대응: 옵션 렌더링 전략 결정
+            const trailingBlocks = 3; // submit + textInput + hint
+            const availableForOptions = SLACK_BLOCK_LIMIT - blocks.length - trailingBlocks;
+            const descriptionCount = question.options.filter(o => o.description).length;
+            const totalWithDesc = question.options.length + descriptionCount;
+            let skipDescriptions = false;
+            let optionsToRender = question.options;
+            if (totalWithDesc > availableForOptions) {
+                skipDescriptions = true;
+                if (question.options.length > availableForOptions) {
+                    // 잘림 안내 context 블록 1개를 위해 -1
+                    const maxOptions = Math.max(1, availableForOptions - 1);
+                    optionsToRender = question.options.slice(0, maxOptions);
+                }
+            }
+            const isTruncated = optionsToRender.length < question.options.length;
+            optionsToRender.forEach((opt, i) => {
+                const isSelected = selectedSet.has(i);
+                const buttonText = isSelected ? `✅ ${opt.label}` : opt.label;
+                const toggleValue = {
+                    questionIndex: 0,
+                    optionIndex: i,
+                    label: opt.label,
+                    projectName,
+                    messageId,
+                };
+                const button = {
+                    type: "button",
+                    text: { type: "plain_text", text: truncateButtonText(buttonText), emoji: true },
+                    value: JSON.stringify(toggleValue),
+                    action_id: `toggle_option_0_${i}`,
+                    style: isSelected ? "primary" : undefined,
+                };
+                blocks.push({
+                    type: "actions",
+                    elements: [button],
+                });
+                // 설명이 있으면 버튼 아래에 표시 (블록 제한 시 생략)
+                if (!skipDescriptions && opt.description) {
+                    blocks.push({
+                        type: "context",
+                        elements: [{ type: "plain_text", text: opt.description, emoji: false }],
+                    });
+                }
+            });
+            if (isTruncated) {
+                blocks.push({
+                    type: "context",
+                    elements: [{ type: "mrkdwn", text: t("question.truncatedOptions", { shown: String(optionsToRender.length), total: String(question.options.length) }) }],
+                });
+            }
+        }
+        // 선택 완료 버튼
+        const submitValue = {
+            questionIndex: 0,
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "submit_multi_select_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.submitSelection"), emoji: true },
+                    value: JSON.stringify(submitValue),
+                    action_id: "submit_multi_select_0",
+                    style: "primary",
+                },
+            ],
+        });
+        // 직접 입력 버튼 (멀티 선택에서도 직접 입력 가능)
+        const multiSelectTextInputValue = {
+            questionIndex: 0,
+            type: "text_input",
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "text_input_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.textInput"), emoji: true },
+                    value: JSON.stringify(multiSelectTextInputValue),
+                    action_id: "text_input_0",
+                },
+            ],
+        });
+        // 현재 선택된 항목 안내
+        if (selectedOptionIndexes.length > 0) {
+            const selectedLabels = selectedOptionIndexes
+                .map(i => question.options[i]?.label)
+                .filter(Boolean)
+                .join(", ");
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: t("question.currentSelection", { labels: selectedLabels }) }],
+            });
+        }
+        else {
+            blocks.push({
+                type: "context",
+                elements: [{ type: "mrkdwn", text: t("question.selectHint") }],
+            });
+        }
+    }
+    else {
+        // 단일 선택 모드 - 기존 로직
+        if (question.options && question.options.length > 0) {
+            // Slack 블록 50개 제한 대응: 옵션 렌더링 전략 결정
+            const trailingBlocks = 1; // textInput
+            const availableForOptions = SLACK_BLOCK_LIMIT - blocks.length - trailingBlocks;
+            const descriptionCount = question.options.filter(o => o.description).length;
+            const totalWithDesc = question.options.length + descriptionCount;
+            let skipDescriptions = false;
+            let optionsToRender = question.options;
+            if (totalWithDesc > availableForOptions) {
+                skipDescriptions = true;
+                if (question.options.length > availableForOptions) {
+                    const maxOptions = Math.max(1, availableForOptions - 1);
+                    optionsToRender = question.options.slice(0, maxOptions);
+                }
+            }
+            const isTruncated = optionsToRender.length < question.options.length;
+            optionsToRender.forEach((opt, i) => {
+                const buttonValue = {
+                    questionIndex: 0,
+                    optionIndex: i,
+                    label: opt.label,
+                    isMultiSelect: false,
+                    projectName,
+                    messageId,
+                };
+                const button = {
+                    type: "button",
+                    text: { type: "plain_text", text: truncateButtonText(opt.label), emoji: true },
+                    value: JSON.stringify(buttonValue),
+                    action_id: `select_option_0_${i}`,
+                };
+                blocks.push({
+                    type: "actions",
+                    elements: [button],
+                });
+                // 설명이 있으면 버튼 아래에 표시 (블록 제한 시 생략)
+                if (!skipDescriptions && opt.description) {
+                    blocks.push({
+                        type: "context",
+                        elements: [{ type: "plain_text", text: opt.description, emoji: false }],
+                    });
+                }
+            });
+            if (isTruncated) {
+                blocks.push({
+                    type: "context",
+                    elements: [{ type: "mrkdwn", text: t("question.truncatedOptions", { shown: String(optionsToRender.length), total: String(question.options.length) }) }],
+                });
+            }
+        }
+        // 직접 입력 버튼
+        const textInputValue = {
+            questionIndex: 0,
+            type: "text_input",
+            projectName,
+            messageId,
+        };
+        blocks.push({
+            type: "actions",
+            block_id: "text_input_0",
+            elements: [
+                {
+                    type: "button",
+                    text: { type: "plain_text", text: t("question.textInput"), emoji: true },
+                    value: JSON.stringify(textInputValue),
+                    action_id: "text_input_0",
+                },
+            ],
+        });
+    }
+    return blocks;
+}

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,83 @@
+import bolt from "@slack/bolt";
+const { App, LogLevel } = bolt;
+import { writeFileSync, unlinkSync } from "fs";
+import { config } from "./core/config.js";
+import { initLocale } from "./i18n/index.js";
+import { createLogger, createBoltLogger } from "./core/logger.js";
+import { registerClaudeCommand, registerQuestionHandlers, registerInitHandlers } from "./handlers/index.js";
+import { sessionManager } from "./claude/session-manager.js";
+import { killAllRunners } from "./claude/active-runners.js";
+import { PID_FILE } from "./core/paths.js";
+// locale은 앞으로 env 기반 선택이 추가될 수 있어, config 접근 전에 미리 초기화한다.
+// (현재는 en만 지원하므로 initLocale은 no-op)
+initLocale();
+const log = createLogger("server");
+// 글로벌 에러 핸들러 (마지막 방어선)
+process.on("uncaughtException", (error) => {
+    log.error("Uncaught exception", error);
+    killAllRunners();
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch {
+        // 파일이 없을 수 있음
+    }
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    log.error("Unhandled rejection", reason instanceof Error ? reason : { reason });
+});
+const app = new App({
+    token: config.slack.botToken,
+    appToken: config.slack.appToken,
+    socketMode: true,
+    logLevel: LogLevel.INFO,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logger: createBoltLogger(),
+});
+// 핸들러 등록
+registerClaudeCommand(app);
+registerQuestionHandlers(app);
+registerInitHandlers(app);
+// Graceful shutdown: 자식 프로세스 정리 후 종료
+let shuttingDown = false;
+async function gracefulShutdown(signal) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    log.info("Shutdown signal received, cleaning up", { signal });
+    const killed = killAllRunners();
+    log.info("Active runners terminated", { count: killed });
+    try {
+        await app.stop();
+        log.info("Slack app stopped");
+    }
+    catch (error) {
+        log.error("Error stopping Slack app", error);
+    }
+    // PID 파일 정리
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch {
+        // 파일이 없을 수 있음
+    }
+    // in-flight 비동기 작업(Slack 메시지 전송 등)이 완료될 시간 확보
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    process.exit(0);
+}
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+// 서버 시작
+(async () => {
+    await app.start();
+    // PID 파일 작성 (daemon stop 시 프로세스 트리 종료에 사용)
+    // 서버 시작 성공 후 작성해야 실패 시 stale PID 파일이 남지 않음
+    writeFileSync(PID_FILE, String(process.pid));
+    log.info("Server started (Socket Mode)", {
+        activeSessions: sessionManager.getActiveCount(),
+    });
+})().catch((error) => {
+    log.error("Failed to start server", error);
+    process.exit(1);
+});

package/dist/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 {};