@pollit/twin-dev-bot 0.0.1

package/dist/core/logger.js

@@ -0,0 +1,110 @@
+import { createWriteStream } from "fs";
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function safeStringify(data) {
+    if (data instanceof Error) {
+        return JSON.stringify({ message: data.message, stack: data.stack });
+    }
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+class Logger {
+    level;
+    context;
+    static logStream = null;
+    constructor(level = "info", context) {
+        this.level = level;
+        this.context = context;
+    }
+    static enableFileLogging(filePath) {
+        if (Logger.logStream) {
+            Logger.logStream.end();
+        }
+        Logger.logStream = createWriteStream(filePath, { flags: "a" });
+        Logger.logStream.on("error", (err) => {
+            console.error("Log file write error:", err.message);
+        });
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const prefix = this.context ? `[${this.context}] ` : "";
+        const dataStr = data !== undefined ? ` ${safeStringify(data)}` : "";
+        return `${timestamp} ${level.toUpperCase().padEnd(5)} ${prefix}${message}${dataStr}`;
+    }
+    output(formatted) {
+        console.error(formatted);
+        Logger.logStream?.write(formatted + "\n");
+    }
+    debug(message, data) {
+        if (this.shouldLog("debug")) {
+            this.output(this.formatMessage("debug", message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog("info")) {
+            this.output(this.formatMessage("info", message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog("warn")) {
+            this.output(this.formatMessage("warn", message, data));
+        }
+    }
+    error(message, error) {
+        if (this.shouldLog("error")) {
+            const errorData = error instanceof Error
+                ? { message: error.message, stack: error.stack }
+                : error;
+            this.output(this.formatMessage("error", message, errorData));
+        }
+    }
+    child(context) {
+        const childContext = this.context ? `${this.context}:${context}` : context;
+        return new Logger(this.level, childContext);
+    }
+}
+const VALID_LOG_LEVELS = new Set(Object.keys(LOG_LEVELS));
+function parseLogLevel(envValue) {
+    if (envValue && VALID_LOG_LEVELS.has(envValue)) {
+        return envValue;
+    }
+    if (envValue) {
+        console.error(`Invalid LOG_LEVEL "${envValue}". Valid values: ${[...VALID_LOG_LEVELS].join(", ")}. Falling back to "info".`);
+    }
+    return "info";
+}
+export const logger = new Logger(parseLogLevel(process.env.LOG_LEVEL));
+export function createLogger(context) {
+    return logger.child(context);
+}
+export function enableFileLogging(filePath) {
+    Logger.enableFileLogging(filePath);
+}
+/**
+ * Slack Bolt용 로거 어댑터.
+ * Bolt 내부 로그를 커스텀 로거로 라우팅하여
+ * 타임스탬프 + stderr 출력을 일관되게 유지한다.
+ */
+export function createBoltLogger() {
+    let boltLog = logger.child("bolt");
+    return {
+        debug(...msg) { boltLog.debug(msg.map(String).join(" ")); },
+        info(...msg) { boltLog.info(msg.map(String).join(" ")); },
+        warn(...msg) { boltLog.warn(msg.map(String).join(" ")); },
+        error(...msg) { boltLog.error(msg.map(String).join(" ")); },
+        setLevel() { },
+        getLevel() { return "info"; },
+        setName(name) { boltLog = logger.child(name); },
+    };
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,11 @@
+export declare const ENV_FILE: string;
+export declare const DATA_DIR: string;
+export declare const SESSIONS_FILE: string;
+export declare const WORKSPACES_FILE: string;
+export declare const CHANNELS_FILE: string;
+export declare const LOG_DIR: string;
+export declare const LOG_OUT: string;
+export declare const LOG_ERR: string;
+export declare const PID_FILE: string;
+/** DATA_DIR, LOG_DIR 가 없으면 생성. 서버/데몬 기동 시에만 호출할 것 */
+export declare function ensureDirs(): void;

package/dist/core/paths.js

@@ -0,0 +1,18 @@
+import { mkdirSync } from "fs";
+import { join } from "path";
+// 프로젝트 루트: 프로세스 실행 디렉토리 기준
+const PROJECT_ROOT = process.cwd();
+export const ENV_FILE = join(PROJECT_ROOT, ".env");
+export const DATA_DIR = join(PROJECT_ROOT, "data");
+export const SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+export const WORKSPACES_FILE = join(DATA_DIR, "workspaces.json");
+export const CHANNELS_FILE = join(DATA_DIR, "channels.json");
+export const LOG_DIR = join(PROJECT_ROOT, "logs");
+export const LOG_OUT = join(LOG_DIR, "twindevbot.out.log");
+export const LOG_ERR = join(LOG_DIR, "twindevbot.err.log");
+export const PID_FILE = join(DATA_DIR, "twindevbot.pid");
+/** DATA_DIR, LOG_DIR 가 없으면 생성. 서버/데몬 기동 시에만 호출할 것 */
+export function ensureDirs() {
+    mkdirSync(DATA_DIR, { recursive: true });
+    mkdirSync(LOG_DIR, { recursive: true });
+}

package/dist/core/platform.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cross-platform home directory.
+ * Replaces all instances of: process.env.HOME || "/root"
+ */
+export declare function getHomeDir(): string;
+/**
+ * Cross-platform tilde expansion.
+ * Replaces ~/ (or ~\) with the user's home directory.
+ */
+export declare function expandTilde(p: string): string;
+/**
+ * Default base directory for projects.
+ */
+export declare function getDefaultBaseDir(): string;
+/**
+ * Whether the current platform supports daemon management.
+ */
+export declare function isDaemonSupported(): boolean;

package/dist/core/platform.js

@@ -0,0 +1,33 @@
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Cross-platform home directory.
+ * Replaces all instances of: process.env.HOME || "/root"
+ */
+export function getHomeDir() {
+    return homedir();
+}
+/**
+ * Cross-platform tilde expansion.
+ * Replaces ~/ (or ~\) with the user's home directory.
+ */
+export function expandTilde(p) {
+    if (p === "~")
+        return getHomeDir();
+    if (p.startsWith("~/") || p.startsWith("~\\")) {
+        return join(getHomeDir(), p.slice(2));
+    }
+    return p;
+}
+/**
+ * Default base directory for projects.
+ */
+export function getDefaultBaseDir() {
+    return join(getHomeDir(), "Desktop");
+}
+/**
+ * Whether the current platform supports daemon management.
+ */
+export function isDaemonSupported() {
+    return process.platform === "darwin" || process.platform === "win32";
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonManager } from "./types.js";
+export type { DaemonManager } from "./types.js";
+export declare function createDaemonManager(): Promise<DaemonManager>;

package/dist/daemon/index.js

@@ -0,0 +1,14 @@
+export async function createDaemonManager() {
+    switch (process.platform) {
+        case "darwin": {
+            const { MacOSDaemonManager } = await import("./macos.js");
+            return new MacOSDaemonManager();
+        }
+        case "win32": {
+            const { WindowsDaemonManager } = await import("./windows.js");
+            return new WindowsDaemonManager();
+        }
+        default:
+            throw new Error(`Daemon management is not supported on ${process.platform}`);
+    }
+}

package/dist/daemon/macos.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonManager } from "./types.js";
+export declare class MacOSDaemonManager implements DaemonManager {
+    start(): void;
+    stop(): void;
+    status(): void;
+    isRunning(): boolean;
+    getLogViewCommand(logPath: string): string;
+}

package/dist/daemon/macos.js

@@ -0,0 +1,150 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getHomeDir } from "../core/platform.js";
+import { LOG_OUT, LOG_ERR } from "../core/paths.js";
+import { t } from "../i18n/index.js";
+const LABEL = "com.twin-dev-bot";
+const PLIST_DIR = join(getHomeDir(), "Library", "LaunchAgents");
+const PLIST_PATH = join(PLIST_DIR, `${LABEL}.plist`);
+const GUI_DOMAIN = `gui/${process.getuid()}`;
+function getNodePath() {
+    try {
+        return execSync("which node", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "/usr/local/bin/node";
+    }
+}
+function getTwindevbotPath() {
+    try {
+        return execSync("which twindevbot", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return process.argv[1];
+    }
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function buildPlist() {
+    const nodePath = getNodePath();
+    const cliPath = getTwindevbotPath();
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${escapeXml(LABEL)}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${escapeXml(nodePath)}</string>
+        <string>${escapeXml(cliPath)}</string>
+        <string>start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(process.cwd())}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${escapeXml(process.env.PATH ?? "")}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${escapeXml(LOG_OUT)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(LOG_ERR)}</string>
+</dict>
+</plist>`;
+}
+export class MacOSDaemonManager {
+    start() {
+        if (!existsSync(PLIST_DIR)) {
+            mkdirSync(PLIST_DIR, { recursive: true });
+        }
+        // plist 파일 유무와 관계없이 항상 bootout 시도 (수동 삭제된 경우 대비)
+        try {
+            execSync(`launchctl bootout ${GUI_DOMAIN}/${LABEL}`, { stdio: "ignore" });
+        }
+        catch {
+            // 등록되어 있지 않으면 무시
+        }
+        const plist = buildPlist();
+        writeFileSync(PLIST_PATH, plist);
+        console.log(t("cli.daemon.plistCreated", { path: PLIST_PATH }));
+        try {
+            execSync(`launchctl bootstrap ${GUI_DOMAIN} "${PLIST_PATH}"`);
+            console.log(t("cli.daemon.started"));
+            console.log("");
+            console.log(`  Status:  twindevbot status`);
+            console.log(`  Stop:    twindevbot stop`);
+            console.log(`  Logs:    ${this.getLogViewCommand(LOG_ERR)}`);
+        }
+        catch (err) {
+            console.error(t("cli.daemon.failedToStart"), err);
+            process.exit(1);
+        }
+    }
+    stop() {
+        if (!existsSync(PLIST_PATH)) {
+            console.log(t("cli.daemon.notInstalled"));
+            return;
+        }
+        try {
+            execSync(`launchctl bootout ${GUI_DOMAIN}/${LABEL}`);
+        }
+        catch {
+            // 이미 중지되어 있을 수 있음
+        }
+        unlinkSync(PLIST_PATH);
+        console.log(t("cli.daemon.stopped"));
+    }
+    status() {
+        if (!existsSync(PLIST_PATH)) {
+            console.log(t("cli.status.notInstalled"));
+            console.log(t("cli.status.notInstalledHint"));
+            return;
+        }
+        try {
+            const output = execSync(`launchctl list "${LABEL}"`, {
+                encoding: "utf-8",
+            });
+            const pidMatch = output.match(/"PID"\s*=\s*(\d+)/);
+            if (pidMatch) {
+                console.log(t("cli.status.running", { pid: pidMatch[1] }));
+            }
+            else {
+                console.log(t("cli.status.registered"));
+            }
+            console.log(`  Logs: ${this.getLogViewCommand(LOG_ERR)}`);
+        }
+        catch {
+            console.log(t("cli.status.notRunning"));
+            console.log(t("cli.status.checkLogs"));
+            console.log(`  tail -50 "${LOG_ERR}"`);
+        }
+    }
+    isRunning() {
+        if (!existsSync(PLIST_PATH))
+            return false;
+        try {
+            const output = execSync(`launchctl list "${LABEL}"`, { encoding: "utf-8" });
+            return !!output.match(/"PID"\s*=\s*(\d+)/);
+        }
+        catch {
+            return false;
+        }
+    }
+    getLogViewCommand(logPath) {
+        return `tail -f "${logPath}"`;
+    }
+}

package/dist/daemon/types.d.ts

@@ -0,0 +1,9 @@
+export interface DaemonManager {
+    start(): void;
+    stop(): void;
+    status(): void;
+    /** 데몬이 현재 실행 중인지 확인 */
+    isRunning(): boolean;
+    /** 플랫폼에 맞는 로그 조회 명령어 */
+    getLogViewCommand(logPath: string): string;
+}

package/dist/daemon/types.js

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

package/dist/daemon/windows.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonManager } from "./types.js";
+export declare class WindowsDaemonManager implements DaemonManager {
+    start(): void;
+    stop(): void;
+    status(): void;
+    isRunning(): boolean;
+    getLogViewCommand(logPath: string): string;
+}

package/dist/daemon/windows.js

@@ -0,0 +1,137 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { LOG_DIR, LOG_OUT, LOG_ERR, PID_FILE } from "../core/paths.js";
+import { t } from "../i18n/index.js";
+const TASK_NAME = "TwinDevBot";
+const WRAPPER_SCRIPT = join(LOG_DIR, "twindevbot-daemon.bat");
+function getNodePath() {
+    try {
+        return execSync("where node", { encoding: "utf-8" }).trim().split(/\r?\n/)[0];
+    }
+    catch {
+        return process.execPath;
+    }
+}
+function getTwindevbotPath() {
+    try {
+        return execSync("where twindevbot", { encoding: "utf-8" }).trim().split(/\r?\n/)[0];
+    }
+    catch {
+        return process.argv[1];
+    }
+}
+export class WindowsDaemonManager {
+    start() {
+        // 기존 태스크가 있으면 제거
+        try {
+            execSync(`schtasks /delete /tn "${TASK_NAME}" /f`, { stdio: "ignore" });
+        }
+        catch {
+            // 태스크가 없을 수 있음
+        }
+        const nodePath = getNodePath();
+        const cliPath = getTwindevbotPath();
+        // stdout/stderr를 로그 파일로 리다이렉션하는 래퍼 스크립트 생성
+        // Task Scheduler는 기본적으로 System32 디렉토리에서 실행되므로 프로젝트 루트로 cd 필요
+        const projectRoot = process.cwd();
+        const scriptContent = `@echo off\r\ncd /d "${projectRoot}"\r\n"${nodePath}" "${cliPath}" start 1>>"${LOG_OUT}" 2>>"${LOG_ERR}"\r\n`;
+        writeFileSync(WRAPPER_SCRIPT, scriptContent);
+        const command = `"\\"${WRAPPER_SCRIPT}\\""`;
+        try {
+            execSync(`schtasks /create /tn "${TASK_NAME}" /tr ${command} /sc onlogon /rl limited /f`);
+            console.log(t("cli.daemon.taskCreated", { name: TASK_NAME }));
+            // 태스크를 즉시 실행
+            execSync(`schtasks /run /tn "${TASK_NAME}"`, { stdio: "ignore" });
+            console.log(t("cli.daemon.started"));
+            console.log("");
+            console.log(`  Status:  twindevbot status`);
+            console.log(`  Stop:    twindevbot stop`);
+            console.log(`  Logs:    ${this.getLogViewCommand(LOG_ERR)}`);
+        }
+        catch (err) {
+            console.error(t("cli.daemon.failedToStart"), err);
+            process.exit(1);
+        }
+    }
+    stop() {
+        // PID 파일로 프로세스 트리 전체 종료 (자식 Claude 프로세스 포함)
+        // schtasks /end는 최상위 프로세스만 종료하므로 자식 프로세스가 고아가 됨
+        if (existsSync(PID_FILE)) {
+            try {
+                const pid = readFileSync(PID_FILE, "utf-8").trim();
+                if (!/^\d+$/.test(pid)) {
+                    throw new Error("Invalid PID");
+                }
+                execSync(`taskkill /pid ${pid} /T /F`, { stdio: "ignore" });
+            }
+            catch {
+                // 프로세스가 이미 종료되었을 수 있음
+            }
+            try {
+                unlinkSync(PID_FILE);
+            }
+            catch {
+                // 파일 삭제 실패 무시
+            }
+        }
+        // 실행 중인 태스크 종료 (PID 파일이 없는 경우 대비)
+        try {
+            execSync(`schtasks /end /tn "${TASK_NAME}"`, { stdio: "ignore" });
+        }
+        catch {
+            // 실행 중이 아닐 수 있음
+        }
+        // 태스크 삭제
+        try {
+            execSync(`schtasks /delete /tn "${TASK_NAME}" /f`);
+            console.log(t("cli.daemon.stopped"));
+        }
+        catch {
+            console.log(t("cli.daemon.notInstalled"));
+        }
+        // 래퍼 스크립트 정리
+        if (existsSync(WRAPPER_SCRIPT)) {
+            unlinkSync(WRAPPER_SCRIPT);
+        }
+    }
+    status() {
+        try {
+            const output = execSync(`schtasks /query /tn "${TASK_NAME}" /v /fo list`, { encoding: "utf-8" });
+            const statusMatch = output.match(/Status:\s*(.+)/);
+            if (statusMatch && statusMatch[1].trim() === "Running") {
+                let pid = "-";
+                if (existsSync(PID_FILE)) {
+                    try {
+                        pid = readFileSync(PID_FILE, "utf-8").trim();
+                    }
+                    catch {
+                        // PID 파일 읽기 실패
+                    }
+                }
+                console.log(t("cli.status.running", { pid }));
+            }
+            else {
+                console.log(t("cli.status.registered"));
+            }
+            console.log(`  Logs: ${this.getLogViewCommand(LOG_ERR)}`);
+        }
+        catch {
+            console.log(t("cli.status.notInstalled"));
+            console.log(t("cli.status.notInstalledHint"));
+        }
+    }
+    isRunning() {
+        try {
+            const output = execSync(`schtasks /query /tn "${TASK_NAME}" /v /fo list`, { encoding: "utf-8" });
+            const statusMatch = output.match(/Status:\s*(.+)/);
+            return !!(statusMatch && statusMatch[1].trim() === "Running");
+        }
+        catch {
+            return false;
+        }
+    }
+    getLogViewCommand(logPath) {
+        return `Get-Content "${logPath}" -Wait`;
+    }
+}

package/dist/handlers/claude-command.d.ts

@@ -0,0 +1,2 @@
+import type { App } from "@slack/bolt";
+export declare function registerClaudeCommand(app: App): void;