@pollit/twin-dev-bot 0.0.1 → 0.0.2

package/README.md

@@ -24,6 +24,8 @@ TwinDevBot connects your Slack workspace to Claude Code running on your machine.
 
 ## Requirements
 
+**TwinDevBot is currently only available on macOS.**
+
 Before you begin, make sure you have the following:
 
 1. **Node.js 18 or later**
@@ -35,9 +37,8 @@ Before you begin, make sure you have the following:
    - Install with: `npm install -g @anthropic-ai/claude-code`
    - Verify by running: `claude --version`
 
-3. **macOS for background service**
-   - `twindevbot start --daemon`, `stop`, and `status` are supported on macOS (launchd)
-   - On other platforms, run in the foreground with `twindevbot start`
+3. **Background service**
+   - `twindevbot start --daemon`, `stop`, and `status` are supported (macOS launchd)
 
 4. **A Slack workspace** where you have permission to install apps
 
@@ -60,9 +61,13 @@ You need to create a Slack App in your workspace. This is a one-time setup.
 1. In the left sidebar, click **"Socket Mode"**
 2. Toggle **"Enable Socket Mode"** to ON
 3. You will be asked to create an **App-Level Token**:
+   - Enter a name for the token (e.g., `twindevbot-socket`)
    - Add the `connections:write` scope
    - Click **"Generate"**
-4. **Copy the token** (starts with `xapp-`) — you will need this later
+4. **Copy the token** (starts with `xapp-`)
+
+> [!CAUTION]
+> You will need this later. Save it somewhere safe now.
 
 ### 1.3 Add a Slash Command
 
@@ -111,7 +116,10 @@ You need to create a Slack App in your workspace. This is a one-time setup.
 1. In the left sidebar, click **"Install App"**
 2. Click **"Install to Workspace"**
 3. Review the permissions and click **"Allow"**
-4. **Copy the Bot Token** (starts with `xoxb-`) — you will need this later
+4. **Copy the Bot Token** (starts with `xoxb-`)
+
+> [!CAUTION]
+> You will need this later. Save it somewhere safe now.
 
 ---
 
@@ -120,7 +128,7 @@ You need to create a Slack App in your workspace. This is a one-time setup.
 Open your terminal and run:
 
 ```bash
-npm install -g twin-dev-bot
+npm install -g @pollit/twin-dev-bot
 ```
 
 Verify the installation:

package/bin/twindevbot.js

@@ -9,11 +9,20 @@ const entry = join(projectRoot, "dist", "cli.js");
 
 // start, help 명령만 빌드 (stop, status는 기존 dist 사용)
 const cmd = process.argv[2];
-if (!cmd || cmd === "start" || cmd === "help" || cmd === "--help" || cmd === "-h") {
+if (
+  !cmd ||
+  cmd === "start" ||
+  cmd === "help" ||
+  cmd === "--help" ||
+  cmd === "-h"
+) {
   try {
-    execSync("npx tsc", { cwd: projectRoot, stdio: "inherit" });
-  } catch {
-    // noEmitOnError 미설정 → dist/ 파일은 갱신됨
+    execSync("npx tsc", { cwd: projectRoot, stdio: "pipe" });
+  } catch (error) {
+    // 빌드 에러 시에만 stderr 출력
+    if (error.stderr) {
+      process.stderr.write(error.stderr);
+    }
   }
 }
 execFileSync(process.execPath, [entry, ...process.argv.slice(2)], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pollit/twin-dev-bot",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Slack bot that runs Claude Code via thread-based conversations",
   "type": "module",
   "bin": {

package/dist/action-payload-store.d.ts

@@ -1,22 +0,0 @@
-/**
- * Slack action.value (~2,000 bytes) 및 private_metadata (~3,000 bytes) 크기 제한 대응.
- * 큰 페이로드를 서버 사이드에 저장하고 짧은 키만 버튼 값에 포함.
- * TTL 기반 자동 정리로 메모리 누수 방지.
- */
-/**
- * 페이로드 저장
- */
-export declare function setPayload(key: string, data: unknown, ttlMs?: number): void;
-/**
- * 페이로드 조회 (기본: 조회 후 삭제하지 않음)
- * @param remove true이면 조회 후 삭제 (일회성 데이터용)
- */
-export declare function getPayload<T>(key: string, remove?: boolean): T | null;
-/**
- * 페이로드 삭제
- */
-export declare function removePayload(key: string): void;
-/**
- * 테스트용: 스토어 전체 초기화
- */
-export declare function clearAllPayloads(): void;

package/dist/action-payload-store.js

@@ -1,54 +0,0 @@
-/**
- * Slack action.value (~2,000 bytes) 및 private_metadata (~3,000 bytes) 크기 제한 대응.
- * 큰 페이로드를 서버 사이드에 저장하고 짧은 키만 버튼 값에 포함.
- * TTL 기반 자동 정리로 메모리 누수 방지.
- */
-const store = new Map();
-const DEFAULT_TTL_MS = 2 * 60 * 60 * 1000; // 2시간
-function cleanup() {
-    const now = Date.now();
-    for (const [key, entry] of store) {
-        if (now > entry.expiresAt)
-            store.delete(key);
-    }
-}
-/**
- * 페이로드 저장
- */
-export function setPayload(key, data, ttlMs = DEFAULT_TTL_MS) {
-    cleanup();
-    store.set(key, { data, expiresAt: Date.now() + ttlMs });
-}
-/**
- * 페이로드 조회 (기본: 조회 후 삭제하지 않음)
- * @param remove true이면 조회 후 삭제 (일회성 데이터용)
- */
-export function getPayload(key, remove = false) {
-    const entry = store.get(key);
-    if (!entry)
-        return null;
-    if (Date.now() > entry.expiresAt) {
-        store.delete(key);
-        return null;
-    }
-    if (remove) {
-        store.delete(key);
-    }
-    else {
-        // TTL 갱신: 접근 시 만료 시간 리셋 (사용자가 상호작용 중임을 표시)
-        entry.expiresAt = Date.now() + DEFAULT_TTL_MS;
-    }
-    return entry.data;
-}
-/**
- * 페이로드 삭제
- */
-export function removePayload(key) {
-    store.delete(key);
-}
-/**
- * 테스트용: 스토어 전체 초기화
- */
-export function clearAllPayloads() {
-    store.clear();
-}

package/dist/active-runners.d.ts

@@ -1,44 +0,0 @@
-/**
- * 활성 러너 레지스트리
- *
- * 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/active-runners.js

@@ -1,114 +0,0 @@
-/**
- * 활성 러너 레지스트리
- *
- * Slack 스레드(threadTs)별로 실행 중인 ClaudeRunner 인스턴스를 추적하여
- * 동일 스레드에서 여러 Claude 프로세스가 동시에 실행되는 것을 방지합니다.
- *
- * - 마지막 이벤트 수신 후 config.inactivityTimeoutMs(기본 30분) 동안
- *   활동이 없으면 프로세스를 자동 종료하고 스레드 잠금을 해제합니다.
- * - onTimeout 콜백을 통해 Slack 타임아웃 알림 등 외부 처리가 가능합니다.
- */
-import { createLogger } from "./logger.js";
-import { config } from "./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/channel-store.d.ts

@@ -1,16 +0,0 @@
-/**
- * Channel Store
- *
- * 슬랙 채널과 작업 디렉토리의 매핑을 관리합니다.
- * /twindevbot init으로 설정된 채널별 작업 디렉토리를 영속적으로 저장합니다.
- *
- * 키: channelId (Slack 채널 ID)
- * 값: { directory, projectName }
- */
-export interface ChannelDir {
-    directory: string;
-    projectName: string;
-}
-export declare function setChannelDir(channelId: string, dir: ChannelDir): void;
-export declare function getChannelDir(channelId: string): ChannelDir | undefined;
-export declare function removeChannelDir(channelId: string): void;

package/dist/channel-store.js

@@ -1,91 +0,0 @@
-/**
- * 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-runner.d.ts

@@ -1,57 +0,0 @@
-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;