seogitan 1.0.0

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerLoginCommand(program: Command): void;

package/dist/commands/login.js

@@ -0,0 +1,63 @@
+import * as http from "node:http";
+import { saveTokens } from "../lib/auth.js";
+// Supabase URL에서 프로젝트 ref 추출 → Vercel 배포 URL 추론
+// 또는 환경변수로 직접 지정 가능
+const WEB_URL = process.env.SEOGITAN_WEB_URL || "https://seogitan.vercel.app";
+export function registerLoginCommand(program) {
+    program
+        .command("login")
+        .description("Google 계정으로 로그인합니다 (웹 브라우저 사용)")
+        .action(async () => {
+        const server = http.createServer();
+        await new Promise((resolve, reject) => {
+            server.listen(0, "127.0.0.1", () => {
+                const addr = server.address();
+                if (!addr || typeof addr === "string") {
+                    reject(new Error("서버 주소를 가져올 수 없습니다."));
+                    return;
+                }
+                const port = addr.port;
+                const cliCallback = `http://127.0.0.1:${port}/callback`;
+                server.on("request", async (req, res) => {
+                    if (!req.url?.startsWith("/callback")) {
+                        res.writeHead(404);
+                        res.end();
+                        return;
+                    }
+                    const url = new URL(req.url, `http://127.0.0.1:${port}`);
+                    const accessToken = url.searchParams.get("access_token");
+                    const refreshToken = url.searchParams.get("refresh_token");
+                    const expiresAt = url.searchParams.get("expires_at");
+                    if (!accessToken || !refreshToken) {
+                        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                        res.end("<h1>로그인 실패</h1><p>토큰을 받지 못했습니다.</p>");
+                        reject(new Error("토큰을 받지 못했습니다."));
+                        server.close();
+                        return;
+                    }
+                    saveTokens({
+                        access_token: accessToken,
+                        refresh_token: refreshToken,
+                        expires_at: expiresAt ? parseInt(expiresAt, 10) : Math.floor(Date.now() / 1000) + 3600,
+                    });
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end("<h1>CLI 로그인 성공!</h1><p>이 창을 닫고 터미널로 돌아가세요.</p>");
+                    console.log("로그인 성공!");
+                    server.close();
+                    resolve();
+                    process.exit(0);
+                });
+                // 웹 로그인 페이지로 리다이렉트 (cli_callback 파라미터 포함)
+                const loginUrl = `${WEB_URL}/auth/login?cli_callback=${encodeURIComponent(cliCallback)}`;
+                console.log("브라우저에서 Google 로그인을 진행하세요...");
+                import("open").then(({ default: open }) => open(loginUrl)).catch(() => {
+                    console.log(`브라우저가 자동으로 열리지 않으면 이 URL을 직접 열어주세요:\n${loginUrl}`);
+                });
+            });
+            setTimeout(() => {
+                reject(new Error("로그인 시간 초과 (120초)"));
+                server.close();
+            }, 120_000);
+        });
+    });
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerLogoutCommand(program: Command): void;

package/dist/commands/logout.js

@@ -0,0 +1,10 @@
+import { clearTokens } from "../lib/auth.js";
+export function registerLogoutCommand(program) {
+    program
+        .command("logout")
+        .description("로그아웃합니다")
+        .action(() => {
+        clearTokens();
+        console.log("로그아웃 완료");
+    });
+}

package/dist/commands/meetings.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerMeetingsCommand(program: Command): void;

package/dist/commands/meetings.js

@@ -0,0 +1,160 @@
+import { listMeetings, getMeeting, getMeetingSummary, getMeetingTranscripts, searchMeetings, } from "seogitan-core";
+import { getSupabaseClient } from "../lib/supabase.js";
+import { formatMeetingsList, formatMeetingDetail, formatSearchResults, } from "../lib/output.js";
+import { EXIT_CODES } from "../exit-codes.js";
+export function registerMeetingsCommand(program) {
+    const meetings = program
+        .command("meetings")
+        .description("회의 관리 명령어");
+    // list
+    meetings
+        .command("list")
+        .description("회의 목록을 조회합니다")
+        .option("--status <status>", "필터할 상태")
+        .option("--from <date>", "조회 시작 날짜 (ISO 8601)")
+        .option("--to <date>", "조회 종료 날짜 (ISO 8601)")
+        .option("--limit <n>", "조회할 최대 개수", "10")
+        .option("--json", "JSON 형식으로 출력", false)
+        .action(async (opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const data = await listMeetings(supabase, {
+                limit: parseInt(opts.limit, 10),
+                status: opts.status,
+                date_from: opts.from,
+                date_to: opts.to,
+            });
+            console.log(formatMeetingsList(data, opts.json));
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+    // show
+    meetings
+        .command("show <id>")
+        .description("회의 상세 정보를 조회합니다")
+        .option("--json", "JSON 형식으로 출력", false)
+        .option("--full", "전사록 포함", false)
+        .action(async (id, opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const meeting = await getMeeting(supabase, id);
+            if (!meeting) {
+                console.error(`회의를 찾을 수 없습니다: ${id}`);
+                process.exit(EXIT_CODES.NOT_FOUND);
+            }
+            const summary = await getMeetingSummary(supabase, id);
+            const transcripts = opts.full
+                ? await getMeetingTranscripts(supabase, id)
+                : await getMeetingTranscripts(supabase, id);
+            console.log(formatMeetingDetail(meeting, summary, transcripts, opts.json, opts.full));
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+    // search
+    meetings
+        .command("search <query>")
+        .description("키워드로 회의를 검색합니다")
+        .option("--json", "JSON 형식으로 출력", false)
+        .option("--limit <n>", "조회할 최대 개수", "5")
+        .action(async (query, opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const results = await searchMeetings(supabase, query, parseInt(opts.limit, 10));
+            console.log(formatSearchResults(results, query, opts.json));
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+    // wait
+    meetings
+        .command("wait <id>")
+        .description("회의 처리가 완료될 때까지 대기합니다")
+        .option("--timeout <seconds>", "최대 대기 시간(초)", "120")
+        .action(async (id, opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const timeout = parseInt(opts.timeout, 10) * 1000;
+            const start = Date.now();
+            while (Date.now() - start < timeout) {
+                const meeting = await getMeeting(supabase, id);
+                if (!meeting) {
+                    console.error(`회의를 찾을 수 없습니다: ${id}`);
+                    process.exit(EXIT_CODES.NOT_FOUND);
+                }
+                if (meeting.status === "completed") {
+                    console.log(`회의 처리 완료: ${meeting.title}`);
+                    return;
+                }
+                if (meeting.status === "error") {
+                    console.error(`회의 처리 오류: ${meeting.error_message || "알 수 없는 오류"}`);
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                const elapsed = Math.floor((Date.now() - start) / 1000);
+                process.stderr.write(`\r대기 중... [${meeting.status}] (${elapsed}초)`);
+                await new Promise((r) => setTimeout(r, 5000));
+            }
+            console.error("\n대기 시간 초과");
+            process.exit(EXIT_CODES.ERROR);
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+    // link
+    meetings
+        .command("link <id> <calendar_event_id>")
+        .description("회의에 캘린더 이벤트를 연결합니다")
+        .action(async (id, calendarEventId) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const { error } = await supabase
+                .from("meetings")
+                .update({ calendar_event_id: calendarEventId })
+                .eq("id", id);
+            if (error) {
+                console.error(`업데이트 실패: ${error.message}`);
+                process.exit(EXIT_CODES.ERROR);
+            }
+            console.log("캘린더 이벤트가 연결되었습니다.");
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+    // add-participant
+    meetings
+        .command("add-participant <id> <email>")
+        .description("회의에 참석자를 추가합니다")
+        .option("--name <name>", "참석자 이름")
+        .action(async (id, email, opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            const { error } = await supabase
+                .from("meeting_participants")
+                .insert({
+                meeting_id: id,
+                email,
+                name: opts.name || null,
+            });
+            if (error) {
+                console.error(`참석자 추가 실패: ${error.message}`);
+                process.exit(EXIT_CODES.ERROR);
+            }
+            console.log(`참석자가 추가되었습니다: ${email}`);
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+}

package/dist/commands/record.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRecordCommand(program: Command): void;

package/dist/commands/record.js

@@ -0,0 +1,212 @@
+import { readFileSync } from "node:fs";
+import { getSupabaseClient } from "../lib/supabase.js";
+import { getValidAccessToken } from "../lib/auth.js";
+import { getValidGoogleToken } from "../lib/calendar.js";
+import { checkFfmpegInstalled, listAudioDevices, createAudioRecorder, createTempOutputDir, } from "../lib/audio.js";
+import { triggerChunkTranscription } from "../lib/n8n.js";
+import { EXIT_CODES } from "../exit-codes.js";
+import { fetchTodayEvents, linkCalendarEvent } from "seogitan-core";
+export function registerRecordCommand(program) {
+    program
+        .command("record [title]")
+        .description("터미널에서 회의를 녹음합니다 (5분 단위 자동 업로드)")
+        .option("--device <index>", "오디오 장치 인덱스", "0")
+        .option("--chunk-duration <seconds>", "청크 단위 (초)", "300")
+        .option("--list-devices", "사용 가능한 오디오 장치 목록 출력")
+        .option("--no-calendar", "캘린더 자동 연결을 건너뜁니다")
+        .action(async (title, opts) => {
+        try {
+            // 1. Check ffmpeg
+            checkFfmpegInstalled();
+            if (opts.listDevices) {
+                const devices = listAudioDevices();
+                if (devices.length === 0) {
+                    console.log("사용 가능한 오디오 장치를 찾을 수 없습니다.");
+                }
+                else {
+                    console.log("사용 가능한 오디오 장치:");
+                    for (const d of devices) {
+                        console.log(`  [${d.index}] ${d.name}`);
+                    }
+                }
+                return;
+            }
+            // 2. Auth
+            await getValidAccessToken();
+            const supabase = await getSupabaseClient();
+            const { data: { user }, error: userError } = await supabase.auth.getUser();
+            if (userError || !user) {
+                console.error("사용자 정보를 가져올 수 없습니다. 다시 로그인해주세요.");
+                process.exit(EXIT_CODES.AUTH_FAILURE);
+            }
+            const userId = user.id;
+            const now = new Date();
+            // 3. 임시 제목으로 회의 즉시 생성
+            const tempTitle = title ||
+                `회의 ${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+            const { data: meeting, error: insertError } = await supabase
+                .from("meetings")
+                .insert({
+                title: tempTitle,
+                status: "recording",
+                created_by: userId,
+                date: now.toISOString(),
+            })
+                .select("id")
+                .single();
+            if (insertError || !meeting) {
+                console.error(`회의 생성 실패: ${insertError?.message || "알 수 없는 오류"}`);
+                process.exit(EXIT_CODES.ERROR);
+            }
+            const meetingId = meeting.id;
+            // 4. 녹음 즉시 시작
+            const outputDir = createTempOutputDir(meetingId);
+            const deviceIndex = parseInt(opts.device, 10);
+            const chunkDurationSeconds = parseInt(opts.chunkDuration, 10);
+            const recorder = createAudioRecorder({
+                outputDir,
+                chunkDurationSeconds,
+                deviceIndex,
+            });
+            // 5. 캘린더 병렬 조회 (녹음과 동시 진행, 블로킹 없음)
+            let calendarEvent = null;
+            if (!title && opts.calendar !== false) {
+                // fire-and-forget: 녹음을 블로킹하지 않음
+                (async () => {
+                    try {
+                        const googleToken = await getValidGoogleToken(supabase, userId);
+                        if (!googleToken)
+                            return;
+                        const events = await fetchTodayEvents(googleToken);
+                        const ongoing = events.filter((e) => {
+                            if (e.start.length <= 10)
+                                return false;
+                            const start = new Date(e.start);
+                            const end = new Date(e.end);
+                            return start <= now && now <= end;
+                        });
+                        // 진행 중인 회의가 있으면 자동 매칭 (첫 번째 = 가장 먼저 시작한 회의)
+                        if (ongoing.length > 0) {
+                            calendarEvent = ongoing[0];
+                            // 회의 제목 + calendar_event_id 업데이트
+                            await supabase
+                                .from("meetings")
+                                .update({
+                                title: calendarEvent.title,
+                                calendar_event_id: calendarEvent.id,
+                            })
+                                .eq("id", meetingId);
+                            console.log(`캘린더 연결됨: ${calendarEvent.title} (${ongoing.length > 1 ? `외 ${ongoing.length - 1}건` : ""})`);
+                        }
+                    }
+                    catch {
+                        // 캘린더 조회 실패는 무시 — 녹음에 영향 없음
+                    }
+                })();
+            }
+            // 6. 청크 업로드 콜백
+            recorder.onNewChunk(async (chunkPath, chunkIndex) => {
+                try {
+                    const fileData = readFileSync(chunkPath);
+                    const storagePath = `${userId}/${meetingId}/chunk_${String(chunkIndex).padStart(3, "0")}.wav`;
+                    const { error: uploadError } = await supabase.storage
+                        .from("meeting-audio")
+                        .upload(storagePath, fileData, { contentType: "audio/wav", upsert: false });
+                    if (uploadError) {
+                        console.error(`\n청크 ${chunkIndex} 업로드 실패: ${uploadError.message}`);
+                        return;
+                    }
+                    await supabase.from("meeting_audio_chunks").insert({
+                        meeting_id: meetingId,
+                        chunk_index: chunkIndex,
+                        audio_storage_path: storagePath,
+                        is_final: false,
+                    });
+                    const { data: signedUrlData } = await supabase.storage
+                        .from("meeting-audio")
+                        .createSignedUrl(storagePath, 3600);
+                    if (signedUrlData?.signedUrl) {
+                        await triggerChunkTranscription({
+                            meeting_id: meetingId,
+                            chunk_index: chunkIndex,
+                            audio_signed_url: signedUrlData.signedUrl,
+                            is_final: false,
+                            created_by: userId,
+                        });
+                    }
+                    try {
+                        await getValidAccessToken();
+                    }
+                    catch { }
+                    const recordedMinutes = Math.floor(((chunkIndex + 1) * chunkDurationSeconds) / 60);
+                    console.log(`청크 ${chunkIndex} 업로드 완료 (${recordedMinutes}분 녹음됨)`);
+                }
+                catch (err) {
+                    console.error(`\n청크 ${chunkIndex} 처리 오류: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            });
+            // 7. SIGINT 핸들러
+            let cleaningUp = false;
+            process.once("SIGINT", async () => {
+                if (cleaningUp)
+                    return;
+                cleaningUp = true;
+                console.log("\n녹음 종료 중...");
+                try {
+                    const chunkFiles = await recorder.stop();
+                    if (chunkFiles.length > 0) {
+                        const lastChunkPath = chunkFiles[chunkFiles.length - 1];
+                        const lastChunkIndex = chunkFiles.length - 1;
+                        const storagePath = `${userId}/${meetingId}/chunk_${String(lastChunkIndex).padStart(3, "0")}.wav`;
+                        const fileData = readFileSync(lastChunkPath);
+                        const { error: uploadError } = await supabase.storage
+                            .from("meeting-audio")
+                            .upload(storagePath, fileData, { contentType: "audio/wav", upsert: true });
+                        if (!uploadError) {
+                            await supabase.from("meeting_audio_chunks").upsert({
+                                meeting_id: meetingId,
+                                chunk_index: lastChunkIndex,
+                                audio_storage_path: storagePath,
+                                is_final: true,
+                            }, { onConflict: "meeting_id,chunk_index" });
+                            const { data: signedUrlData } = await supabase.storage
+                                .from("meeting-audio")
+                                .createSignedUrl(storagePath, 3600);
+                            if (signedUrlData?.signedUrl) {
+                                await triggerChunkTranscription({
+                                    meeting_id: meetingId,
+                                    chunk_index: lastChunkIndex,
+                                    audio_signed_url: signedUrlData.signedUrl,
+                                    is_final: true,
+                                    created_by: userId,
+                                });
+                            }
+                        }
+                    }
+                    await supabase.from("meetings").update({ status: "processing_chunks" }).eq("id", meetingId);
+                    // 캘린더 이벤트 매칭 시 참석자 등록
+                    if (calendarEvent && user.email) {
+                        try {
+                            await linkCalendarEvent(supabase, meetingId, calendarEvent, user.email);
+                        }
+                        catch { }
+                    }
+                    console.log(`녹음 완료. Meeting ID: ${meetingId}`);
+                }
+                catch (err) {
+                    console.error(`정리 중 오류: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                process.exit(EXIT_CODES.SUCCESS);
+            });
+            // 8. 녹음 시작!
+            recorder.start();
+            const chunkMinutes = Math.floor(chunkDurationSeconds / 60);
+            console.log(`녹음 시작: ${tempTitle} (${chunkMinutes}분마다 자동 전사, Ctrl+C로 종료)`);
+            console.log(`Meeting ID: ${meetingId}`);
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSetupCommand(program: Command): void;

package/dist/commands/setup.js

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync, cpSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// npm 패키지 내 번들된 스킬 경로 (dist/commands/ → ../../skills)
+const BUNDLED_SKILLS_DIR = join(__dirname, "..", "..", "skills");
+// 설치 대상: ~/.claude/skills/
+const TARGET_SKILLS_DIR = join(homedir(), ".claude", "skills");
+const SEOGITAN_SKILLS = ["record", "meetings", "summary", "upload"];
+export function registerSetupCommand(program) {
+    program
+        .command("setup")
+        .description("Claude Code 스킬을 설치합니다")
+        .option("--force", "기존 스킬을 덮어씁니다")
+        .action(async (opts) => {
+        console.log("🔧 Seogitan 설치를 시작합니다...\n");
+        // 1. 스킬 설치
+        if (!existsSync(BUNDLED_SKILLS_DIR)) {
+            console.error("❌ 번들된 스킬을 찾을 수 없습니다. 패키지가 손상되었을 수 있습니다.");
+            process.exit(1);
+        }
+        mkdirSync(TARGET_SKILLS_DIR, { recursive: true });
+        let installed = 0;
+        let skipped = 0;
+        for (const skill of SEOGITAN_SKILLS) {
+            const src = join(BUNDLED_SKILLS_DIR, skill);
+            const dest = join(TARGET_SKILLS_DIR, `seogitan-${skill}`);
+            if (!existsSync(src)) {
+                console.log(`  ⚠ ${skill} 스킬을 찾을 수 없습니다 (건너뜀)`);
+                continue;
+            }
+            if (existsSync(dest) && !opts.force) {
+                console.log(`  ✓ seogitan-${skill} (이미 설치됨)`);
+                skipped++;
+                continue;
+            }
+            cpSync(src, dest, { recursive: true });
+            console.log(`  ✓ seogitan-${skill} 설치 완료`);
+            installed++;
+        }
+        console.log(`\n📦 스킬 설치: ${installed}개 설치, ${skipped}개 기존 유지`);
+        // 2. 로그인 안내
+        console.log("\n📋 다음 단계:");
+        console.log("  1. seogitan login     — Google 계정으로 로그인");
+        console.log("  2. seogitan record    — 회의 녹음 시작");
+        console.log("  3. Claude Code에서 /seogitan-record, /seogitan-meetings, /seogitan-summary 사용 가능");
+        console.log("");
+    });
+}

package/dist/commands/summarize.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSummarizeCommand(program: Command): void;

package/dist/commands/summarize.js

@@ -0,0 +1,69 @@
+import { getMeeting, getMeetingSummary, getMeetingTranscripts, } from "seogitan-core";
+import { getSupabaseClient } from "../lib/supabase.js";
+import { formatMeetingDetail } from "../lib/output.js";
+import { EXIT_CODES } from "../exit-codes.js";
+import { triggerSummarize } from "../lib/n8n.js";
+export function registerSummarizeCommand(program) {
+    program
+        .command("summarize <meeting-id>")
+        .description("회의 요약을 생성합니다")
+        .option("--wait", "요약 완료까지 대기합니다", false)
+        .option("--timeout <seconds>", "대기 최대 시간(초)", "120")
+        .action(async (meetingId, opts) => {
+        try {
+            const supabase = await getSupabaseClient();
+            // 1. Check meeting exists
+            const meeting = await getMeeting(supabase, meetingId);
+            if (!meeting) {
+                console.error(`회의를 찾을 수 없습니다: ${meetingId}`);
+                process.exit(EXIT_CODES.NOT_FOUND);
+            }
+            // 2. Check transcripts exist
+            const transcripts = await getMeetingTranscripts(supabase, meetingId);
+            if (!transcripts || transcripts.length === 0) {
+                console.error("전사 내용이 없습니다. 먼저 전사를 완료해주세요.");
+                process.exit(EXIT_CODES.ERROR);
+            }
+            // 3. Check if summary already exists
+            const existingSummary = await getMeetingSummary(supabase, meetingId);
+            if (existingSummary) {
+                console.log("이미 요약이 존재합니다.");
+                process.exit(EXIT_CODES.SUCCESS);
+            }
+            // 4. Trigger n8n summarize webhook
+            await triggerSummarize(meetingId);
+            console.log("요약 생성을 요청했습니다.");
+            // 5. If --wait, poll until complete
+            if (opts.wait) {
+                const timeout = parseInt(opts.timeout, 10) * 1000;
+                const start = Date.now();
+                while (Date.now() - start < timeout) {
+                    await new Promise((r) => setTimeout(r, 5000));
+                    const current = await getMeeting(supabase, meetingId);
+                    if (!current) {
+                        console.error(`회의를 찾을 수 없습니다: ${meetingId}`);
+                        process.exit(EXIT_CODES.NOT_FOUND);
+                    }
+                    if (current.status === "completed") {
+                        const summary = await getMeetingSummary(supabase, meetingId);
+                        const txs = await getMeetingTranscripts(supabase, meetingId);
+                        console.log(formatMeetingDetail(current, summary, txs, false, false));
+                        return;
+                    }
+                    if (current.status === "error") {
+                        console.error(`요약 생성 오류: ${current.error_message || "알 수 없는 오류"}`);
+                        process.exit(EXIT_CODES.ERROR);
+                    }
+                    const elapsed = Math.floor((Date.now() - start) / 1000);
+                    process.stderr.write(`\r요약 대기 중... [${current.status}] (${elapsed}초)`);
+                }
+                console.error("\n대기 시간 초과");
+                process.exit(EXIT_CODES.ERROR);
+            }
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+}

package/dist/commands/upload.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerUploadCommand(program: Command): void;