seogitan 1.0.0

package/dist/commands/upload.js

@@ -0,0 +1,186 @@
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { basename, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdirSync } from "node:fs";
+import { getSupabaseClient } from "../lib/supabase.js";
+import { getValidAccessToken } from "../lib/auth.js";
+import { getValidGoogleToken } from "../lib/calendar.js";
+import { triggerChunkTranscription } from "../lib/n8n.js";
+import { EXIT_CODES } from "../exit-codes.js";
+import { linkCalendarEvent } from "seogitan-core";
+export function registerUploadCommand(program) {
+    program
+        .command("upload <file>")
+        .description("녹음된 오디오 파일을 업로드하여 전사/요약합니다")
+        .option("-t, --title <title>", "회의 제목")
+        .option("--calendar", "업로드 후 오늘 캘린더에서 선택 (인터랙티브)")
+        .option("--calendar-date <YYYY-MM-DD>", "특정 날짜의 캘린더에서 선택")
+        .option("--calendar-search <query>", "캘린더 일정을 제목으로 검색 (최근 30일)")
+        .option("--calendar-index <n>", "검색/날짜 결과에서 N번째 일정을 자동 선택 (1부터)")
+        .option("--chunk-duration <seconds>", "청크 단위 (초)", "300")
+        .action(async (file, opts) => {
+        try {
+            const filePath = resolve(file);
+            if (!existsSync(filePath)) {
+                console.error(`파일을 찾을 수 없습니다: ${filePath}`);
+                process.exit(EXIT_CODES.ERROR);
+            }
+            const fileSize = statSync(filePath).size;
+            console.log(`파일: ${basename(filePath)} (${(fileSize / 1024 / 1024).toFixed(1)}MB)`);
+            // 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 title = opts.title || `업로드 ${basename(filePath)}`;
+            const chunkDuration = parseInt(opts.chunkDuration, 10);
+            // 1. 회의 생성
+            const { data: meeting, error: insertError } = await supabase
+                .from("meetings")
+                .insert({
+                title,
+                status: "recording",
+                created_by: userId,
+                date: new Date().toISOString(),
+            })
+                .select("id")
+                .single();
+            if (insertError || !meeting) {
+                console.error(`회의 생성 실패: ${insertError?.message}`);
+                process.exit(EXIT_CODES.ERROR);
+            }
+            const meetingId = meeting.id;
+            console.log(`Meeting ID: ${meetingId}`);
+            // 2. ffmpeg로 WAV 청크 분할
+            const chunkDir = `${tmpdir()}/seogitan-upload-${meetingId}`;
+            mkdirSync(chunkDir, { recursive: true });
+            console.log(`청크 분할 중 (${chunkDuration}초 단위)...`);
+            execSync(`ffmpeg -i "${filePath}" -ar 16000 -ac 1 -f segment -segment_time ${chunkDuration} -segment_format wav "${chunkDir}/chunk_%03d.wav" -y`, { stdio: "pipe" });
+            // 3. 청크 파일 목록
+            const { readdirSync } = await import("node:fs");
+            const chunkFiles = readdirSync(chunkDir)
+                .filter((f) => f.endsWith(".wav"))
+                .sort();
+            console.log(`${chunkFiles.length}개 청크 생성됨`);
+            // 4. 각 청크 업로드 + n8n 트리거
+            for (let i = 0; i < chunkFiles.length; i++) {
+                const chunkPath = `${chunkDir}/${chunkFiles[i]}`;
+                const chunkData = readFileSync(chunkPath);
+                const storagePath = `${userId}/${meetingId}/chunk_${String(i).padStart(3, "0")}.wav`;
+                const isFinal = i === chunkFiles.length - 1;
+                // Upload to Storage
+                const { error: uploadError } = await supabase.storage
+                    .from("meeting-audio")
+                    .upload(storagePath, chunkData, { contentType: "audio/wav" });
+                if (uploadError) {
+                    console.error(`청크 ${i} 업로드 실패: ${uploadError.message}`);
+                    continue;
+                }
+                // Insert chunk record
+                await supabase.from("meeting_audio_chunks").insert({
+                    meeting_id: meetingId,
+                    chunk_index: i,
+                    audio_storage_path: storagePath,
+                    is_final: isFinal,
+                });
+                // Signed URL
+                const { data: signedData } = await supabase.storage
+                    .from("meeting-audio")
+                    .createSignedUrl(storagePath, 3600);
+                if (signedData?.signedUrl) {
+                    await triggerChunkTranscription({
+                        meeting_id: meetingId,
+                        chunk_index: i,
+                        audio_signed_url: signedData.signedUrl,
+                        is_final: isFinal,
+                        created_by: userId,
+                    });
+                }
+                console.log(`청크 ${i}/${chunkFiles.length - 1} 업로드 완료${isFinal ? " (최종)" : ""}`);
+            }
+            // 5. 상태 업데이트
+            await supabase
+                .from("meetings")
+                .update({ status: "processing_chunks" })
+                .eq("id", meetingId);
+            // 6. 캘린더 연결
+            const wantCalendar = opts.calendar || opts.calendarDate || opts.calendarSearch;
+            if (wantCalendar) {
+                try {
+                    const googleToken = await getValidGoogleToken(supabase, userId);
+                    if (!googleToken) {
+                        console.log("Google 캘린더에 접근할 수 없습니다. seogitan login으로 재로그인하세요.");
+                    }
+                    else {
+                        const { fetchTodayEvents: fetchToday, fetchEventsByDate, searchEvents } = await import("seogitan-core");
+                        let events = [];
+                        if (opts.calendarSearch) {
+                            // 제목 검색 (최근 30일) — Claude Skill에서 사용
+                            events = await searchEvents(googleToken, opts.calendarSearch);
+                            if (events.length > 0)
+                                console.log(`\n"${opts.calendarSearch}" 검색 결과 (${events.length}건):`);
+                        }
+                        else if (opts.calendarDate) {
+                            // 특정 날짜 — Claude Skill에서 사용
+                            events = await fetchEventsByDate(googleToken, new Date(opts.calendarDate));
+                            if (events.length > 0)
+                                console.log(`\n${opts.calendarDate} 일정 (${events.length}건):`);
+                        }
+                        else {
+                            // 오늘 (인터랙티브)
+                            events = await fetchToday(googleToken);
+                            if (events.length > 0)
+                                console.log(`\n오늘의 일정 (${events.length}건):`);
+                        }
+                        if (events.length === 0) {
+                            console.log("해당하는 일정이 없습니다.");
+                        }
+                        else {
+                            events.forEach((e, i) => {
+                                const date = new Date(e.start).toLocaleDateString("ko-KR", { month: "short", day: "numeric" });
+                                const isAllDay = e.start.length <= 10;
+                                const time = isAllDay ? "종일" :
+                                    new Date(e.start).toLocaleTimeString("ko-KR", { hour: "2-digit", minute: "2-digit", hour12: false });
+                                console.log(`  [${i + 1}] ${e.title} (${date} ${time}, ${e.attendees.length}명)`);
+                            });
+                            let selectedIndex = -1;
+                            if (opts.calendarIndex) {
+                                // 비인터랙티브: --calendar-index로 자동 선택 (Claude Skill용)
+                                selectedIndex = parseInt(opts.calendarIndex, 10) - 1;
+                            }
+                            else {
+                                // 인터랙티브: 사용자 선택
+                                console.log("  [0] 건너뛰기\n");
+                                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                                const answer = await new Promise((resolve) => {
+                                    rl.question("연결할 일정 선택: ", (ans) => { rl.close(); resolve(ans.trim()); });
+                                });
+                                selectedIndex = parseInt(answer, 10) - 1;
+                            }
+                            if (selectedIndex >= 0 && selectedIndex < events.length) {
+                                const selected = events[selectedIndex];
+                                await linkCalendarEvent(supabase, meetingId, selected, user.email);
+                                console.log(`캘린더 연결됨: ${selected.title}`);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // 캘린더 연결 실패는 업로드에 영향 없음
+                }
+            }
+            console.log(`\n업로드 완료! 전사/요약이 진행됩니다.`);
+            console.log(`확인: seogitan meetings show ${meetingId}`);
+        }
+        catch (err) {
+            console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export declare const SUPABASE_URL: string;
+export declare const SUPABASE_ANON_KEY: string;
+export declare const SUPABASE_FUNCTIONS_URL: string;

package/dist/config.js

@@ -0,0 +1,11 @@
+// Supabase 공개 설정 (anon key는 브라우저에도 노출되는 공개 키)
+// 환경변수로 오버라이드 가능 (개발/테스트용)
+export const SUPABASE_URL = process.env.SUPABASE_URL ||
+    process.env.NEXT_PUBLIC_SUPABASE_URL ||
+    "https://pnedwqbbuqviykngpdbi.supabase.co";
+export const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY ||
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ||
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBuZWR3cWJidXF2aXlrbmdwZGJpIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzQ1NTc2NDYsImV4cCI6MjA5MDEzMzY0Nn0.cbLANAeWNy6XxL-dhOIdnGRV_C0c68lLM94H1-nk-fg";
+// Supabase Edge Functions URL
+export const SUPABASE_FUNCTIONS_URL = process.env.SUPABASE_FUNCTIONS_URL ||
+    "https://pnedwqbbuqviykngpdbi.supabase.co/functions/v1";

package/dist/exit-codes.d.ts

@@ -0,0 +1,8 @@
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly ERROR: 1;
+    readonly MISUSE: 2;
+    readonly AUTH_FAILURE: 3;
+    readonly NOT_FOUND: 4;
+    readonly NETWORK_ERROR: 5;
+};

package/dist/exit-codes.js

@@ -0,0 +1,8 @@
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    ERROR: 1,
+    MISUSE: 2,
+    AUTH_FAILURE: 3,
+    NOT_FOUND: 4,
+    NETWORK_ERROR: 5,
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerLoginCommand } from "./commands/login.js";
+import { registerLogoutCommand } from "./commands/logout.js";
+import { registerMeetingsCommand } from "./commands/meetings.js";
+import { registerRecordCommand } from "./commands/record.js";
+import { registerSummarizeCommand } from "./commands/summarize.js";
+import { registerUploadCommand } from "./commands/upload.js";
+import { registerSetupCommand } from "./commands/setup.js";
+import { checkSkillsInstalled } from "./lib/skills.js";
+import { EXIT_CODES } from "./exit-codes.js";
+const program = new Command();
+program
+    .name("seogitan")
+    .description("서기탄이 CLI - 회의 녹음 & AI 요약 서비스")
+    .version("1.0.0");
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerMeetingsCommand(program);
+registerRecordCommand(program);
+registerSummarizeCommand(program);
+registerUploadCommand(program);
+registerSetupCommand(program);
+// setup, login, logout 이외의 명령어 실행 시 스킬 미설치 안내
+const subcommand = process.argv[2];
+if (subcommand && !["setup", "login", "logout", "--help", "-h", "--version", "-V"].includes(subcommand)) {
+    checkSkillsInstalled();
+}
+program.parseAsync(process.argv).catch((err) => {
+    console.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(EXIT_CODES.ERROR);
+});

package/dist/lib/audio.d.ts

@@ -0,0 +1,18 @@
+export interface AudioRecorderOptions {
+    outputDir: string;
+    chunkDurationSeconds?: number;
+    deviceIndex?: number;
+}
+export interface AudioRecorder {
+    start(): void;
+    stop(): Promise<string[]>;
+    onNewChunk(callback: (chunkPath: string, chunkIndex: number) => void): void;
+}
+export declare function checkFfmpegInstalled(): void;
+export interface AudioDevice {
+    index: number;
+    name: string;
+}
+export declare function listAudioDevices(): AudioDevice[];
+export declare function createAudioRecorder(options: AudioRecorderOptions): AudioRecorder;
+export declare function createTempOutputDir(meetingId: string): string;

package/dist/lib/audio.js

@@ -0,0 +1,185 @@
+import { spawn, execSync } from "node:child_process";
+import { watch, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+export function checkFfmpegInstalled() {
+    try {
+        execSync("ffmpeg -version", { stdio: "pipe" });
+    }
+    catch {
+        throw new Error("ffmpeg가 설치되어 있지 않습니다.\n" +
+            "macOS: brew install ffmpeg\n" +
+            "Ubuntu/Debian: sudo apt install ffmpeg\n" +
+            "자세한 정보: https://ffmpeg.org/download.html");
+    }
+}
+export function listAudioDevices() {
+    try {
+        // ffmpeg exits with error code when listing devices, so we must catch
+        execSync("ffmpeg -f avfoundation -list_devices true -i dummy", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        return [];
+    }
+    catch (err) {
+        // ffmpeg writes device list to stderr even on "error" exit
+        if (err && typeof err === "object" && "stderr" in err) {
+            return parseAudioDevices(err.stderr);
+        }
+        return [];
+    }
+}
+function parseAudioDevices(output) {
+    const devices = [];
+    const lines = output.split("\n");
+    let inAudioSection = false;
+    for (const line of lines) {
+        if (line.includes("AVFoundation audio devices:")) {
+            inAudioSection = true;
+            continue;
+        }
+        if (inAudioSection && line.includes("AVFoundation video devices:")) {
+            break;
+        }
+        if (inAudioSection) {
+            // Match lines like: [AVFoundation indev @ 0x...] [0] Built-in Microphone
+            const match = line.match(/\[(\d+)]\s+(.+)$/);
+            if (match) {
+                devices.push({
+                    index: parseInt(match[1], 10),
+                    name: match[2].trim(),
+                });
+            }
+        }
+    }
+    return devices;
+}
+export function createAudioRecorder(options) {
+    const { outputDir, chunkDurationSeconds = 300, deviceIndex = 0, } = options;
+    let ffmpegProcess = null;
+    let chunkCallback = null;
+    let lastSeenIndex = -1;
+    let watcher = null;
+    // Build ffmpeg args based on platform
+    function buildFfmpegArgs() {
+        const inputArgs = process.platform === "darwin"
+            ? ["-f", "avfoundation", "-i", `:${deviceIndex}`]
+            : ["-f", "pulse", "-i", "default"];
+        return [
+            ...inputArgs,
+            "-ar",
+            "16000",
+            "-ac",
+            "1",
+            "-f",
+            "segment",
+            "-segment_time",
+            String(chunkDurationSeconds),
+            "-segment_format",
+            "wav",
+            join(outputDir, "chunk_%03d.wav"),
+        ];
+    }
+    function getChunkFiles() {
+        if (!existsSync(outputDir))
+            return [];
+        return readdirSync(outputDir)
+            .filter((f) => f.startsWith("chunk_") && f.endsWith(".wav"))
+            .sort();
+    }
+    function getChunkIndex(filename) {
+        const match = filename.match(/chunk_(\d+)\.wav/);
+        return match ? parseInt(match[1], 10) : -1;
+    }
+    function handleNewFile() {
+        const files = getChunkFiles();
+        if (files.length === 0)
+            return;
+        const highestIndex = Math.max(...files.map(getChunkIndex));
+        // When a new chunk file appears, the PREVIOUS chunk is complete
+        if (highestIndex > lastSeenIndex && lastSeenIndex >= 0 && chunkCallback) {
+            // All chunks from lastSeenIndex up to highestIndex-1 are complete
+            // (normally just one at a time, but handle edge cases)
+            for (let i = lastSeenIndex; i < highestIndex; i++) {
+                const completedFile = `chunk_${String(i).padStart(3, "0")}.wav`;
+                const completedPath = join(outputDir, completedFile);
+                if (existsSync(completedPath)) {
+                    chunkCallback(completedPath, i);
+                }
+            }
+        }
+        lastSeenIndex = highestIndex;
+    }
+    const recorder = {
+        start() {
+            if (!existsSync(outputDir)) {
+                mkdirSync(outputDir, { recursive: true });
+            }
+            const args = buildFfmpegArgs();
+            ffmpegProcess = spawn("ffmpeg", args, {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            ffmpegProcess.on("error", (err) => {
+                throw new Error(`ffmpeg 실행 실패: ${err.message}`);
+            });
+            ffmpegProcess.stderr?.on("data", (data) => {
+                const text = data.toString();
+                // Check for device errors
+                if (text.includes("No such device") || text.includes("Device not found")) {
+                    throw new Error(`오디오 장치를 찾을 수 없습니다 (index: ${deviceIndex}). ` +
+                        "`seogitan record --list-devices`로 사용 가능한 장치를 확인하세요.");
+                }
+            });
+            // Watch for new chunk files
+            watcher = watch(outputDir, (eventType, filename) => {
+                if (filename &&
+                    filename.startsWith("chunk_") &&
+                    filename.endsWith(".wav")) {
+                    // Small delay to let ffmpeg finish writing headers of new file
+                    setTimeout(handleNewFile, 500);
+                }
+            });
+        },
+        async stop() {
+            return new Promise((resolve, reject) => {
+                if (!ffmpegProcess) {
+                    resolve(getChunkFiles().map((f) => join(outputDir, f)));
+                    return;
+                }
+                const timeout = setTimeout(() => {
+                    ffmpegProcess?.kill("SIGTERM");
+                }, 5000);
+                ffmpegProcess.on("close", () => {
+                    clearTimeout(timeout);
+                    if (watcher) {
+                        watcher.close();
+                        watcher = null;
+                    }
+                    resolve(getChunkFiles().map((f) => join(outputDir, f)));
+                });
+                ffmpegProcess.on("error", (err) => {
+                    clearTimeout(timeout);
+                    if (watcher) {
+                        watcher.close();
+                        watcher = null;
+                    }
+                    reject(new Error(`ffmpeg 종료 실패: ${err.message}`));
+                });
+                // Send 'q' to gracefully stop ffmpeg
+                if (ffmpegProcess.stdin?.writable) {
+                    ffmpegProcess.stdin.write("q\n");
+                }
+                else {
+                    ffmpegProcess.kill("SIGTERM");
+                }
+            });
+        },
+        onNewChunk(callback) {
+            chunkCallback = callback;
+        },
+    };
+    return recorder;
+}
+export function createTempOutputDir(meetingId) {
+    const dir = join(tmpdir(), `seogitan-${meetingId}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+declare const TokensSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodString;
+    expires_at: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+}, {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+}>;
+export type Tokens = z.infer<typeof TokensSchema>;
+export declare function loadTokens(): Tokens | null;
+export declare function saveTokens(tokens: Tokens): void;
+export declare function clearTokens(): void;
+export declare function refreshAccessToken(refreshToken: string): Promise<Tokens>;
+export declare function getValidAccessToken(): Promise<string>;
+export {};

package/dist/lib/auth.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+const CONFIG_DIR = path.join(os.homedir(), ".config", "seogitan");
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+const TokensSchema = z.object({
+    access_token: z.string(),
+    refresh_token: z.string(),
+    expires_at: z.number(),
+});
+export function loadTokens() {
+    try {
+        const raw = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        return TokensSchema.parse(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveTokens(tokens) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    const validated = TokensSchema.parse(tokens);
+    const content = JSON.stringify(validated, null, 2);
+    // Atomic write: write to temp file then rename
+    const tmpFile = path.join(CONFIG_DIR, `.credentials.${crypto.randomUUID()}.tmp`);
+    fs.writeFileSync(tmpFile, content, { mode: 0o600 });
+    fs.renameSync(tmpFile, CREDENTIALS_FILE);
+}
+export function clearTokens() {
+    try {
+        fs.unlinkSync(CREDENTIALS_FILE);
+    }
+    catch {
+        // File may not exist, that's fine
+    }
+}
+import { SUPABASE_URL, SUPABASE_ANON_KEY } from "../config.js";
+export async function refreshAccessToken(refreshToken) {
+    const supabaseUrl = SUPABASE_URL;
+    const supabaseAnonKey = SUPABASE_ANON_KEY;
+    const response = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            apikey: supabaseAnonKey,
+        },
+        body: JSON.stringify({ refresh_token: refreshToken }),
+    });
+    if (!response.ok) {
+        throw new Error(`토큰 갱신 실패: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const tokens = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Math.floor(Date.now() / 1000) + data.expires_in,
+    };
+    saveTokens(tokens);
+    return tokens;
+}
+export async function getValidAccessToken() {
+    const tokens = loadTokens();
+    if (!tokens) {
+        throw new Error("로그인이 필요합니다. `seogitan login` 명령어를 실행하세요.");
+    }
+    const now = Math.floor(Date.now() / 1000);
+    // Refresh if less than 300 seconds remaining
+    if (tokens.expires_at - now < 300) {
+        const refreshed = await refreshAccessToken(tokens.refresh_token);
+        return refreshed.access_token;
+    }
+    return tokens.access_token;
+}

package/dist/lib/calendar.d.ts

@@ -0,0 +1,6 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+/**
+ * profiles에서 Google access token을 가져오고, 만료 시 Edge Function으로 갱신합니다.
+ * Supabase JWT와는 별개의 Google OAuth 토큰입니다.
+ */
+export declare function getValidGoogleToken(supabase: SupabaseClient, userId: string): Promise<string | null>;

package/dist/lib/calendar.js

@@ -0,0 +1,37 @@
+import { SUPABASE_FUNCTIONS_URL } from "../config.js";
+import { getValidAccessToken } from "./auth.js";
+/**
+ * profiles에서 Google access token을 가져오고, 만료 시 Edge Function으로 갱신합니다.
+ * Supabase JWT와는 별개의 Google OAuth 토큰입니다.
+ */
+export async function getValidGoogleToken(supabase, userId) {
+    const { data: profile } = await supabase
+        .from("profiles")
+        .select("google_access_token")
+        .eq("id", userId)
+        .single();
+    if (!profile?.google_access_token)
+        return null;
+    // Google Calendar API 테스트로 유효성 검사
+    const testRes = await fetch("https://www.googleapis.com/calendar/v3/users/me/calendarList?maxResults=1", { headers: { Authorization: `Bearer ${profile.google_access_token}` } });
+    if (testRes.ok)
+        return profile.google_access_token;
+    // 만료 → Supabase Edge Function으로 refresh
+    try {
+        const supabaseToken = await getValidAccessToken();
+        const refreshRes = await fetch(`${SUPABASE_FUNCTIONS_URL}/refresh-google-token`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${supabaseToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!refreshRes.ok)
+            return null;
+        const { access_token } = await refreshRes.json();
+        return access_token || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/n8n.d.ts

@@ -0,0 +1,10 @@
+export interface ChunkUploadedPayload {
+    meeting_id: string;
+    chunk_index: number;
+    audio_signed_url: string;
+    is_final: boolean;
+    created_by: string;
+    attendees?: string[];
+}
+export declare function triggerChunkTranscription(payload: ChunkUploadedPayload): Promise<void>;
+export declare function triggerSummarize(meetingId: string): Promise<void>;

package/dist/lib/n8n.js

@@ -0,0 +1,24 @@
+import { SUPABASE_FUNCTIONS_URL } from "../config.js";
+import { getValidAccessToken } from "./auth.js";
+const TRIGGER_WEBHOOK_URL = `${SUPABASE_FUNCTIONS_URL}/trigger-n8n-webhook`;
+async function callEdgeFunction(action, payload) {
+    const accessToken = await getValidAccessToken();
+    const res = await fetch(TRIGGER_WEBHOOK_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({ action, ...payload }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Edge Function 호출 실패 (${res.status}): ${body}`);
+    }
+}
+export async function triggerChunkTranscription(payload) {
+    await callEdgeFunction("chunk-uploaded", payload);
+}
+export async function triggerSummarize(meetingId) {
+    await callEdgeFunction("summarize", { meeting_id: meetingId });
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,4 @@
+import type { Meeting, Summary, Transcript, SearchResult } from "seogitan-core";
+export declare function formatMeetingsList(meetings: Meeting[], json: boolean): string;
+export declare function formatMeetingDetail(meeting: Meeting, summary: Summary | null, transcripts: Transcript[], json: boolean, full?: boolean): string;
+export declare function formatSearchResults(results: SearchResult[], query: string, json: boolean): string;