@pollit/twin-dev-bot 0.0.1

package/dist/cli.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+import dotenv from "dotenv";
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { confirm } from "@inquirer/prompts";
+import { ENV_FILE, LOG_ERR, SESSIONS_FILE, WORKSPACES_FILE, ensureDirs } from "./core/paths.js";
+import { initLocale, t } from "./i18n/index.js";
+import { ensureConfig } from "./setup.js";
+import { isDaemonSupported } from "./core/platform.js";
+import { createDaemonManager } from "./daemon/index.js";
+import { getDisplayWidth } from "./utils/display-width.js";
+// .env 로드 → locale 초기화
+dotenv.config({ path: ENV_FILE, override: true });
+initLocale();
+function wrapText(text, maxWidth) {
+    const words = text.split(" ");
+    const lines = [];
+    let line = "";
+    let lineWidth = 0;
+    for (const word of words) {
+        const wordWidth = getDisplayWidth(word);
+        const gap = line ? 1 : 0;
+        if (lineWidth + gap + wordWidth > maxWidth && line) {
+            lines.push(line);
+            line = word;
+            lineWidth = wordWidth;
+        }
+        else {
+            line = line ? line + " " + word : word;
+            lineWidth += gap + wordWidth;
+        }
+    }
+    if (line)
+        lines.push(line);
+    return lines;
+}
+function buildWarningBox(text, innerWidth) {
+    const red = "\x1b[31m";
+    const reset = "\x1b[0m";
+    const lines = wrapText(text, innerWidth);
+    const border = "─".repeat(innerWidth + 2);
+    const top = `  ${red}┌${border}┐${reset}`;
+    const bottom = `  ${red}└${border}┘${reset}`;
+    const empty = `  ${red}│${" ".repeat(innerWidth + 2)}│${reset}`;
+    const content = lines.map((l) => {
+        const pad = innerWidth - getDisplayWidth(l);
+        return `  ${red}│ ${l}${" ".repeat(pad)} │${reset}`;
+    });
+    return [
+        "",
+        `  ${red}${t("cli.warning.title")}${reset}`,
+        top,
+        empty,
+        ...content,
+        empty,
+        bottom,
+    ].join("\n");
+}
+function getLogViewHint() {
+    if (process.platform === "win32") {
+        return `Get-Content "${LOG_ERR}" -Wait`;
+    }
+    return `tail -f "${LOG_ERR}"`;
+}
+function printHelp() {
+    console.log(`
+twindevbot - ${t("cli.description")}
+
+${t("cli.usage")}
+  twindevbot <command> [options]
+
+${t("cli.commands")}
+  start               ${t("cli.cmd.start")}
+  start --daemon, -d  ${t("cli.cmd.startDaemon")}
+  stop                ${t("cli.cmd.stop")}
+  status              ${t("cli.cmd.status")}
+  show                ${t("cli.cmd.show")}
+  clear               ${t("cli.cmd.clear")}
+  help                ${t("cli.cmd.help")}
+
+${t("cli.notes")}
+  1. ${t("cli.notes.daemon")}
+  2. ${t("cli.notes.errorLog")}
+     ${LOG_ERR}
+${buildWarningBox(t("cli.warning.text"), 62)}
+`);
+}
+function ensureDaemonSupported() {
+    if (!isDaemonSupported()) {
+        console.error(t("cli.daemonUnsupportedPlatform", { platform: process.platform }));
+        process.exit(1);
+    }
+}
+async function startDaemon() {
+    ensureDaemonSupported();
+    const manager = await createDaemonManager();
+    manager.start();
+}
+async function stopDaemon() {
+    ensureDaemonSupported();
+    const manager = await createDaemonManager();
+    manager.stop();
+}
+async function showStatus() {
+    ensureDaemonSupported();
+    const manager = await createDaemonManager();
+    manager.status();
+}
+function formatDateTime(dateStr) {
+    const d = new Date(dateStr);
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function formatRelativeTime(dateStr) {
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const minutes = Math.floor(diff / 60_000);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return t("cli.show.daysAgo", { n: days });
+    if (hours > 0)
+        return t("cli.show.hoursAgo", { n: hours });
+    if (minutes > 0)
+        return t("cli.show.minutesAgo", { n: minutes });
+    return t("cli.show.justNow");
+}
+function showSessions() {
+    const dim = "\x1b[2m";
+    const bold = "\x1b[1m";
+    const cyan = "\x1b[36m";
+    const yellow = "\x1b[33m";
+    const green = "\x1b[32m";
+    const magenta = "\x1b[35m";
+    const rst = "\x1b[0m";
+    if (!existsSync(SESSIONS_FILE)) {
+        console.log(`\n  ${t("cli.show.noSessions")}\n`);
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(SESSIONS_FILE, "utf-8"));
+    }
+    catch {
+        console.error(`\n  ${t("cli.show.parseError")}\n`);
+        return;
+    }
+    if (!data.sessions || data.sessions.length === 0) {
+        console.log(`\n  ${t("cli.show.noSessions")}\n`);
+        return;
+    }
+    // group by projectName
+    const grouped = new Map();
+    for (const s of data.sessions) {
+        const arr = grouped.get(s.projectName) || [];
+        arr.push(s);
+        grouped.set(s.projectName, arr);
+    }
+    // header box
+    const total = data.sessions.length;
+    const title = t("cli.show.title", { count: total });
+    const titleWidth = getDisplayWidth(title);
+    const innerWidth = Math.max(titleWidth + 4, 38);
+    const padLeft = Math.floor((innerWidth - titleWidth) / 2);
+    const padRight = innerWidth - titleWidth - padLeft;
+    console.log("");
+    console.log(`  ${dim}┌${"─".repeat(innerWidth)}┐${rst}`);
+    console.log(`  ${dim}│${rst}${" ".repeat(padLeft)}${bold}${title}${rst}${" ".repeat(padRight)}${dim}│${rst}`);
+    console.log(`  ${dim}└${"─".repeat(innerWidth)}┘${rst}`);
+    for (const [projectName, sessions] of grouped) {
+        const countLabel = t("cli.show.sessionCount", { count: sessions.length });
+        console.log("");
+        console.log(`  ${bold}${cyan}${projectName}${rst}  ${dim}${countLabel}${rst}`);
+        sessions.forEach((s, i) => {
+            const isLast = i === sessions.length - 1;
+            const prefix = isLast ? "└─" : "├─";
+            const sid = s.sessionId.length > 12 ? s.sessionId.slice(0, 12) + "…" : s.sessionId;
+            const started = formatDateTime(s.startedAt);
+            const lastAct = formatRelativeTime(s.lastActivityAt);
+            const autopilotBadge = s.autopilot ? `  ${magenta}autopilot${rst}` : "";
+            console.log(`  ${dim}${prefix}${rst} ${yellow}${sid}${rst}  ${dim}${started}${rst}  ${green}${lastAct}${rst}${autopilotBadge}`);
+        });
+    }
+    console.log("");
+}
+// ── clear command ─────────────────────────────────────────────
+async function clearData() {
+    // 데몬이 실행 중이면 경고
+    if (isDaemonSupported()) {
+        try {
+            const manager = await createDaemonManager();
+            if (manager.isRunning()) {
+                console.log(`\n  ${t("cli.clear.daemonRunning")}\n`);
+                return;
+            }
+        }
+        catch {
+            // 데몬 상태 확인 실패 → 무시하고 진행
+        }
+    }
+    const targets = [SESSIONS_FILE, WORKSPACES_FILE].filter((f) => existsSync(f));
+    if (targets.length === 0) {
+        console.log(`\n  ${t("cli.clear.noData")}\n`);
+        return;
+    }
+    console.log(`\n  ${t("cli.clear.header")}`);
+    for (const f of targets) {
+        console.log(`  • ${f}`);
+    }
+    console.log("");
+    const ok = await confirm({ message: t("cli.clear.confirm"), default: false });
+    if (!ok) {
+        console.log(`\n  ${t("cli.clear.cancelled")}\n`);
+        return;
+    }
+    for (const f of targets) {
+        unlinkSync(f);
+    }
+    console.log(`\n  ${t("cli.clear.done")}\n`);
+}
+// ── start command ─────────────────────────────────────────────
+async function start(daemon) {
+    ensureDirs();
+    await ensureConfig(daemon);
+    if (daemon) {
+        await startDaemon();
+        return;
+    }
+    // 포그라운드 실행 시 로그를 파일에도 기록
+    // (daemon 모드에서는 launchd가 stderr를 파일로 리다이렉트하므로 중복 방지)
+    if (process.stderr.isTTY) {
+        const { enableFileLogging } = await import("./core/logger.js");
+        enableFileLogging(LOG_ERR);
+    }
+    await import("./server.js");
+}
+const command = process.argv[2];
+const flags = process.argv.slice(3);
+const isDaemon = flags.includes("--daemon") || flags.includes("-d");
+(async () => {
+    switch (command) {
+        case "start":
+            await start(isDaemon);
+            break;
+        case undefined:
+            printHelp();
+            break;
+        case "stop":
+            await stopDaemon();
+            break;
+        case "status":
+            await showStatus();
+            break;
+        case "show":
+            showSessions();
+            break;
+        case "clear":
+            await clearData();
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+            printHelp();
+            break;
+        default:
+            console.error(t("cli.unknownCommand", { command }));
+            printHelp();
+            process.exit(1);
+    }
+})().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export declare const config: {
+    readonly slack: {
+        botToken: string;
+        appToken: string;
+    };
+    readonly baseDir: string;
+    readonly inactivityTimeoutMinutes: number;
+    readonly inactivityTimeoutMs: number;
+};

package/dist/config.js

@@ -0,0 +1,49 @@
+import dotenv from "dotenv";
+import { ENV_FILE } from "./paths.js";
+import { createLogger } from "./logger.js";
+import { expandTilde, getDefaultBaseDir } from "./platform.js";
+const log = createLogger("config");
+let _initialized = false;
+function ensureInit() {
+    if (_initialized)
+        return;
+    _initialized = true;
+    dotenv.config({ path: ENV_FILE, override: true });
+    const missing = [];
+    if (!process.env.SLACK_BOT_TOKEN)
+        missing.push("SLACK_BOT_TOKEN");
+    if (!process.env.SLACK_APP_TOKEN)
+        missing.push("SLACK_APP_TOKEN");
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(", ")}. ` +
+            `Please configure them in your .env file.`);
+    }
+}
+export const config = {
+    get slack() {
+        ensureInit();
+        return {
+            botToken: process.env.SLACK_BOT_TOKEN,
+            appToken: process.env.SLACK_APP_TOKEN,
+        };
+    },
+    get baseDir() {
+        ensureInit();
+        const raw = process.env.TWINDEVBOT_BASE_DIR;
+        return raw ? expandTilde(raw) : getDefaultBaseDir();
+    },
+    get inactivityTimeoutMinutes() {
+        ensureInit();
+        const DEFAULT_MINUTES = 30;
+        const raw = process.env.INACTIVITY_TIMEOUT_MINUTES;
+        const parsed = parseInt(raw || String(DEFAULT_MINUTES), 10);
+        if (isNaN(parsed) || parsed < 1) {
+            log.warn(`Invalid INACTIVITY_TIMEOUT_MINUTES="${raw}", using default ${DEFAULT_MINUTES} minutes`);
+            return DEFAULT_MINUTES;
+        }
+        return parsed;
+    },
+    get inactivityTimeoutMs() {
+        return this.inactivityTimeoutMinutes * 60 * 1000;
+    },
+};

package/dist/conversation-store.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 대화 파일 관리 모듈
+ *
+ * 각 프로젝트의 작업 디렉토리에 conversation 폴더를 생성하고 대화를 관리합니다.
+ * 파일 경로:
+ *   - {directory}/conversation/dialogue.json - 처리 완료된 메시지 기록 (SAVE_DIALOGUE=true 시)
+ *   - {directory}/conversation/claude-output-raw.jsonl - Claude CLI 원본 출력 (SAVE_CLAUDE_OUTPUT_RAW=true 시)
+ */
+import type { ConversationFile, Message, MessageType, MessageContent } from "./types/conversation.js";
+/**
+ * 작업 디렉토리에서 conversation 디렉토리 경로 반환
+ */
+export declare function getConversationDir(directory: string): string;
+/**
+ * dialogue.json 파일 경로 반환
+ */
+export declare function getDialoguePath(directory: string): string;
+/**
+ * claude-output-raw.jsonl 파일 경로 반환
+ */
+export declare function getRawOutputPath(directory: string): string;
+/**
+ * conversation 디렉토리가 존재하는지 확인하고, 없으면 생성
+ */
+export declare function ensureConversationDir(directory: string): void;
+/**
+ * 대화 파일 로드
+ */
+export declare function loadConversation(directory: string): ConversationFile | null;
+/**
+ * 대화 파일 저장
+ */
+export declare function saveConversation(directory: string, conversation: ConversationFile): boolean;
+/**
+ * 새 대화 파일 생성
+ */
+export declare function createConversation(projectName: string, directory: string, slackChannelId: string): ConversationFile | null;
+/**
+ * 대화 파일 로드 또는 생성
+ */
+export declare function getOrCreateConversation(projectName: string, directory: string, slackChannelId: string): ConversationFile | null;
+/**
+ * 처리 완료된 메시지 기록
+ *
+ * dialogue.json에는 처리가 성공적으로 끝난 것만 기록됩니다.
+ * - Claude 메시지: Slack 전송 성공 후 기록
+ * - 사용자 메시지: Claude 입력 성공 후 기록
+ */
+export declare function recordMessage(directory: string, type: MessageType, content: MessageContent): Message | null;
+/**
+ * Claude 세션 ID 업데이트
+ */
+export declare function updateClaudeSessionId(directory: string, sessionId: string): boolean;

package/dist/conversation-store.js

@@ -0,0 +1,173 @@
+/**
+ * 대화 파일 관리 모듈
+ *
+ * 각 프로젝트의 작업 디렉토리에 conversation 폴더를 생성하고 대화를 관리합니다.
+ * 파일 경로:
+ *   - {directory}/conversation/dialogue.json - 처리 완료된 메시지 기록 (SAVE_DIALOGUE=true 시)
+ *   - {directory}/conversation/claude-output-raw.jsonl - Claude CLI 원본 출력 (SAVE_CLAUDE_OUTPUT_RAW=true 시)
+ */
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { createLogger } from "./logger.js";
+import { config } from "./config.js";
+const log = createLogger("conversation-store");
+/**
+ * 작업 디렉토리에서 conversation 디렉토리 경로 반환
+ */
+export function getConversationDir(directory) {
+    return join(directory, "conversation");
+}
+/**
+ * dialogue.json 파일 경로 반환
+ */
+export function getDialoguePath(directory) {
+    return join(getConversationDir(directory), "dialogue.json");
+}
+/**
+ * claude-output-raw.jsonl 파일 경로 반환
+ */
+export function getRawOutputPath(directory) {
+    return join(getConversationDir(directory), "claude-output-raw.jsonl");
+}
+/**
+ * conversation 디렉토리가 존재하는지 확인하고, 없으면 생성
+ */
+export function ensureConversationDir(directory) {
+    const conversationDir = getConversationDir(directory);
+    if (!existsSync(conversationDir)) {
+        mkdirSync(conversationDir, { recursive: true });
+        log.debug("Created conversation directory", { dir: conversationDir });
+    }
+}
+/**
+ * 대화 파일 로드
+ */
+export function loadConversation(directory) {
+    if (!config.dialogue.save) {
+        return null;
+    }
+    const filePath = getDialoguePath(directory);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        log.error("Failed to load dialogue file", { directory, error });
+        return null;
+    }
+}
+/**
+ * 대화 파일 저장
+ */
+export function saveConversation(directory, conversation) {
+    if (!config.dialogue.save) {
+        return true; // 저장 비활성화 시 성공으로 처리
+    }
+    ensureConversationDir(directory);
+    const filePath = getDialoguePath(directory);
+    try {
+        conversation.updatedAt = new Date().toISOString();
+        writeFileSync(filePath, JSON.stringify(conversation, null, 2));
+        log.debug("Dialogue saved", { directory });
+        return true;
+    }
+    catch (error) {
+        log.error("Failed to save dialogue file", { directory, error });
+        return false;
+    }
+}
+/**
+ * 새 대화 파일 생성
+ */
+export function createConversation(projectName, directory, slackChannelId) {
+    if (!config.dialogue.save) {
+        return null;
+    }
+    ensureConversationDir(directory);
+    const now = new Date().toISOString();
+    const conversation = {
+        projectName,
+        directory,
+        slackChannelId,
+        claudeSessionId: null,
+        createdAt: now,
+        updatedAt: now,
+        messages: [],
+    };
+    saveConversation(directory, conversation);
+    log.info("Created new dialogue", { projectName, directory });
+    return conversation;
+}
+/**
+ * 대화 파일 로드 또는 생성
+ */
+export function getOrCreateConversation(projectName, directory, slackChannelId) {
+    if (!config.dialogue.save) {
+        return null;
+    }
+    const existing = loadConversation(directory);
+    if (existing) {
+        // 기존 대화가 있으면 채널 ID 업데이트 (다른 채널에서 시작할 수 있음)
+        existing.slackChannelId = slackChannelId;
+        saveConversation(directory, existing);
+        return existing;
+    }
+    return createConversation(projectName, directory, slackChannelId);
+}
+/**
+ * 메시지 ID 생성
+ */
+function generateMessageId() {
+    return randomUUID();
+}
+/**
+ * 처리 완료된 메시지 기록
+ *
+ * dialogue.json에는 처리가 성공적으로 끝난 것만 기록됩니다.
+ * - Claude 메시지: Slack 전송 성공 후 기록
+ * - 사용자 메시지: Claude 입력 성공 후 기록
+ */
+export function recordMessage(directory, type, content) {
+    if (!config.dialogue.save) {
+        return null; // 저장 비활성화 시 건너뜀
+    }
+    let conversation = loadConversation(directory);
+    if (!conversation) {
+        log.error("Dialogue not found", { directory });
+        return null;
+    }
+    const message = {
+        id: generateMessageId(),
+        type,
+        timestamp: new Date().toISOString(),
+        processed: true, // 기록 시점에 이미 처리 완료
+        content,
+    };
+    conversation.messages.push(message);
+    saveConversation(directory, conversation);
+    log.debug("Message recorded", {
+        directory,
+        messageId: message.id,
+        type,
+    });
+    return message;
+}
+/**
+ * Claude 세션 ID 업데이트
+ */
+export function updateClaudeSessionId(directory, sessionId) {
+    if (!config.dialogue.save) {
+        return true; // 저장 비활성화 시 성공으로 처리
+    }
+    const conversation = loadConversation(directory);
+    if (!conversation) {
+        return false;
+    }
+    conversation.claudeSessionId = sessionId;
+    saveConversation(directory, conversation);
+    return true;
+}

package/dist/core/config.d.ts

@@ -0,0 +1,9 @@
+export declare const config: {
+    readonly slack: {
+        botToken: string;
+        appToken: string;
+    };
+    readonly baseDir: string;
+    readonly inactivityTimeoutMinutes: number;
+    readonly inactivityTimeoutMs: number;
+};

package/dist/core/config.js

@@ -0,0 +1,49 @@
+import dotenv from "dotenv";
+import { ENV_FILE } from "./paths.js";
+import { createLogger } from "./logger.js";
+import { expandTilde, getDefaultBaseDir } from "./platform.js";
+const log = createLogger("config");
+let _initialized = false;
+function ensureInit() {
+    if (_initialized)
+        return;
+    _initialized = true;
+    dotenv.config({ path: ENV_FILE, override: true });
+    const missing = [];
+    if (!process.env.SLACK_BOT_TOKEN)
+        missing.push("SLACK_BOT_TOKEN");
+    if (!process.env.SLACK_APP_TOKEN)
+        missing.push("SLACK_APP_TOKEN");
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(", ")}. ` +
+            `Please configure them in your .env file.`);
+    }
+}
+export const config = {
+    get slack() {
+        ensureInit();
+        return {
+            botToken: process.env.SLACK_BOT_TOKEN,
+            appToken: process.env.SLACK_APP_TOKEN,
+        };
+    },
+    get baseDir() {
+        ensureInit();
+        const raw = process.env.TWINDEVBOT_BASE_DIR;
+        return raw ? expandTilde(raw) : getDefaultBaseDir();
+    },
+    get inactivityTimeoutMinutes() {
+        ensureInit();
+        const DEFAULT_MINUTES = 30;
+        const raw = process.env.INACTIVITY_TIMEOUT_MINUTES;
+        const parsed = parseInt(raw || String(DEFAULT_MINUTES), 10);
+        if (isNaN(parsed) || parsed < 1) {
+            log.warn(`Invalid INACTIVITY_TIMEOUT_MINUTES="${raw}", using default ${DEFAULT_MINUTES} minutes`);
+            return DEFAULT_MINUTES;
+        }
+        return parsed;
+    },
+    get inactivityTimeoutMs() {
+        return this.inactivityTimeoutMinutes * 60 * 1000;
+    },
+};

package/dist/core/logger.d.ts

@@ -0,0 +1,34 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+declare class Logger {
+    private level;
+    private context?;
+    private static logStream;
+    constructor(level?: LogLevel, context?: string);
+    static enableFileLogging(filePath: string): void;
+    private shouldLog;
+    private formatMessage;
+    private output;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, error?: unknown): void;
+    child(context: string): Logger;
+}
+export declare const logger: Logger;
+export declare function createLogger(context: string): Logger;
+export declare function enableFileLogging(filePath: string): void;
+/**
+ * Slack Bolt용 로거 어댑터.
+ * Bolt 내부 로그를 커스텀 로거로 라우팅하여
+ * 타임스탬프 + stderr 출력을 일관되게 유지한다.
+ */
+export declare function createBoltLogger(): {
+    debug(...msg: unknown[]): void;
+    info(...msg: unknown[]): void;
+    warn(...msg: unknown[]): void;
+    error(...msg: unknown[]): void;
+    setLevel(level: string): void;
+    getLevel(): string;
+    setName(name: string): void;
+};
+export {};