@pollit/twin-dev-bot 0.0.1

package/dist/session-manager.js

@@ -0,0 +1,247 @@
+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/setup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * .env 파일을 확인하고 비어있는 값이 있으면 인터랙티브 프롬프트로 입력받는다.
+ * 모든 값이 채워져 있으면 프롬프트 없이 통과한다.
+ */
+export declare function ensureConfig(daemon: boolean): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,132 @@
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import dotenv from "dotenv";
+import { input } from "@inquirer/prompts";
+import { ENV_FILE } from "./core/paths.js";
+import { initLocale, t } from "./i18n/index.js";
+import { getDefaultBaseDir, expandTilde } from "./core/platform.js";
+import { getDisplayWidth } from "./utils/display-width.js";
+function loadCurrentEnv() {
+    if (!existsSync(ENV_FILE))
+        return {};
+    const parsed = dotenv.parse(readFileSync(ENV_FILE, "utf-8"));
+    return {
+        SLACK_APP_TOKEN: parsed.SLACK_APP_TOKEN || undefined,
+        SLACK_BOT_TOKEN: parsed.SLACK_BOT_TOKEN || undefined,
+        TWINDEVBOT_BASE_DIR: parsed.TWINDEVBOT_BASE_DIR || undefined,
+        LOG_LEVEL: parsed.LOG_LEVEL || undefined,
+    };
+}
+function writeEnvFile(values) {
+    const lines = [
+        `SLACK_BOT_TOKEN="${values.SLACK_BOT_TOKEN}"`,
+        `SLACK_APP_TOKEN="${values.SLACK_APP_TOKEN}"`,
+        `TWINDEVBOT_BASE_DIR="${values.TWINDEVBOT_BASE_DIR}"`,
+        `LOG_LEVEL="${values.LOG_LEVEL}"`,
+    ];
+    writeFileSync(ENV_FILE, lines.join("\n") + "\n");
+    // Unix에서 .env 파일 권한을 소유자만 읽기/쓰기로 설정 (토큰 보호)
+    if (process.platform !== "win32") {
+        try {
+            chmodSync(ENV_FILE, 0o600);
+        }
+        catch { /* ignore */ }
+    }
+}
+const DEFAULT_BASE_DIR = getDefaultBaseDir();
+function printBanner() {
+    const title = t("cli.setup.banner");
+    const titleWidth = getDisplayWidth(title);
+    const innerWidth = 34;
+    const padLeft = Math.floor((innerWidth - titleWidth) / 2);
+    const padRight = innerWidth - titleWidth - padLeft;
+    console.log("");
+    console.log(`  ┌${"─".repeat(innerWidth)}┐`);
+    console.log(`  │${" ".repeat(padLeft)}${title}${" ".repeat(padRight)}│`);
+    console.log(`  └${"─".repeat(innerWidth)}┘`);
+    console.log("");
+}
+function printStartMessage(daemon) {
+    console.log("");
+    if (daemon) {
+        console.log(`  ✅ ${t("cli.setup.startDaemonMessage")}`);
+    }
+    else {
+        console.log(`  ✅ ${t("cli.setup.startMessage")}`);
+    }
+    console.log("");
+}
+function applyToProcessEnv(values) {
+    process.env.SLACK_APP_TOKEN = values.SLACK_APP_TOKEN;
+    process.env.SLACK_BOT_TOKEN = values.SLACK_BOT_TOKEN;
+    process.env.TWINDEVBOT_BASE_DIR = values.TWINDEVBOT_BASE_DIR;
+    process.env.LOG_LEVEL = values.LOG_LEVEL;
+}
+/**
+ * .env 파일을 확인하고 비어있는 값이 있으면 인터랙티브 프롬프트로 입력받는다.
+ * 모든 값이 채워져 있으면 프롬프트 없이 통과한다.
+ */
+export async function ensureConfig(daemon) {
+    const current = loadCurrentEnv();
+    const needAppToken = !current.SLACK_APP_TOKEN;
+    const needBotToken = !current.SLACK_BOT_TOKEN;
+    const needBaseDir = !current.TWINDEVBOT_BASE_DIR;
+    const needsSetup = needAppToken || needBotToken || needBaseDir;
+    if (!needsSetup) {
+        const values = {
+            SLACK_APP_TOKEN: current.SLACK_APP_TOKEN,
+            SLACK_BOT_TOKEN: current.SLACK_BOT_TOKEN,
+            TWINDEVBOT_BASE_DIR: current.TWINDEVBOT_BASE_DIR,
+            LOG_LEVEL: current.LOG_LEVEL ?? "info",
+        };
+        if (!current.LOG_LEVEL) {
+            writeEnvFile(values);
+        }
+        applyToProcessEnv(values);
+        return;
+    }
+    // 비대화형 환경(launchd 데몬 등)에서는 프롬프트를 실행할 수 없으므로 즉시 종료
+    if (!process.stdin.isTTY) {
+        const missing = [
+            needAppToken && "SLACK_APP_TOKEN",
+            needBotToken && "SLACK_BOT_TOKEN",
+            needBaseDir && "TWINDEVBOT_BASE_DIR",
+        ].filter(Boolean);
+        console.error(`[twindevbot] Missing required config: ${missing.join(", ")}. ` +
+            `Run "twindevbot start" interactively to set up, or edit ${ENV_FILE} manually.`);
+        process.exit(1);
+    }
+    printBanner();
+    const maskToken = (v, { isFinal }) => isFinal && v.length > 10 ? v.slice(0, 10) + "..." : v;
+    const appToken = needAppToken
+        ? (await input({
+            message: t("cli.setup.promptAppToken") + "\n ",
+            transformer: maskToken,
+            validate: (v) => (v.trim() ? true : t("cli.setup.required")),
+        })).trim()
+        : current.SLACK_APP_TOKEN;
+    const botToken = needBotToken
+        ? (await input({
+            message: t("cli.setup.promptBotToken") + "\n ",
+            transformer: maskToken,
+            validate: (v) => (v.trim() ? true : t("cli.setup.required")),
+        })).trim()
+        : current.SLACK_BOT_TOKEN;
+    const baseDir = needBaseDir
+        ? expandTilde((await input({
+            message: t("cli.setup.promptBaseDir") + "\n ",
+            default: DEFAULT_BASE_DIR,
+        })).trim())
+        : current.TWINDEVBOT_BASE_DIR;
+    const values = {
+        SLACK_APP_TOKEN: appToken,
+        SLACK_BOT_TOKEN: botToken,
+        TWINDEVBOT_BASE_DIR: baseDir,
+        LOG_LEVEL: current.LOG_LEVEL ?? "info",
+    };
+    writeEnvFile(values);
+    applyToProcessEnv(values);
+    initLocale();
+    console.log("");
+    console.log(`  ✔ ${t("cli.setup.saved", { path: ENV_FILE })}`);
+    printStartMessage(daemon);
+}

package/dist/slack/progress-tracker.d.ts

@@ -0,0 +1,47 @@
+import type { WebClient } from "@slack/web-api";
+export interface ProgressTrackerOptions {
+    client: WebClient;
+    channelId: string;
+    threadTs: string;
+    userMessageTs?: string;
+}
+export declare class ProgressTracker {
+    private client;
+    private channelId;
+    private threadTs;
+    private userMessageTs?;
+    private statusMessageTs?;
+    private startTime;
+    private currentReaction?;
+    private static readonly THROTTLE_MS;
+    private lastUpdateTime;
+    private pendingUpdate;
+    private pendingUpdateTimer;
+    private disposed;
+    constructor(options: ProgressTrackerOptions);
+    /** 사용자 메시지에 👀 리액션 추가 (접수 확인) */
+    markReceived(): Promise<void>;
+    /** 작업 시작 — 👀→⚙️ 교체 + 상태 메시지 게시 */
+    markWorking(): Promise<void>;
+    /** 도구 사용 — 상태 메시지 갱신 (리액션 변경 없음, 5초 쓰로틀) */
+    updateToolUse(toolName: string): Promise<void>;
+    /** 작업 완료 — ⚙️→✅ 교체 + 상태 메시지 갱신 */
+    markCompleted(): Promise<void>;
+    /** 오류 — ⚙️→❌ 교체 + 상태 메시지 갱신 */
+    markError(errorMessage: string): Promise<void>;
+    /** 계획 승인 — ⚙️→👍 교체 + 상태 메시지 갱신 (구현 시작 전 전환 상태) */
+    markPlanApproved(): Promise<void>;
+    /** Autopilot 자동 응답 후 계속 진행 — 리액션 변경 없이 상태 메시지만 갱신 */
+    markAutopilotContinue(): Promise<void>;
+    /** 질문 전송 — ⚙️→✋ 교체 + 상태 메시지 갱신 */
+    markAskUser(): Promise<void>;
+    /** 타이머 정리 — 인스턴스를 더 이상 사용하지 않을 때 호출 */
+    dispose(): void;
+    private setReaction;
+    private swapReaction;
+    private postStatusMessage;
+    private updateStatusMessage;
+    private flushPendingUpdate;
+    private clearPendingUpdate;
+    private getElapsedText;
+}

package/dist/slack/progress-tracker.js

@@ -0,0 +1,218 @@
+import { createLogger } from "../core/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/slack/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 {};