relayax-cli 0.3.58 → 0.3.61

package/dist/commands/package.d.ts

@@ -1,10 +1,39 @@
 import { Command } from 'commander';
+type DiffStatus = 'added' | 'modified' | 'deleted' | 'unchanged';
+interface DiffEntry {
+    relPath: string;
+    status: DiffStatus;
+}
 import type { ContentType } from '../lib/ai-tools.js';
 export interface ContentEntry {
     name: string;
     type: ContentType;
     from: string;
 }
+type ContentDiffStatus = 'modified' | 'unchanged' | 'source_missing';
+interface ContentDiffEntry {
+    name: string;
+    type: ContentType;
+    status: ContentDiffStatus;
+    files?: DiffEntry[];
+}
+interface NewItemEntry {
+    name: string;
+    type: ContentType;
+    source: string;
+    relativePath: string;
+}
+/**
+ * contents 매니페스트 기반으로 각 항목의 원본과 .relay/ 복사본을 비교한다.
+ */
+export declare function computeContentsDiff(contents: ContentEntry[], relayDir: string, projectPath: string): {
+    diff: ContentDiffEntry[];
+    newItems: NewItemEntry[];
+};
+/**
+ * contents 항목 단위로 from → .relay/ 동기화한다.
+ */
+export declare function syncContentsToRelay(contents: ContentEntry[], contentsDiff: ContentDiffEntry[], relayDir: string, projectPath: string): void;
 /**
  * 패키지 홈 디렉토리를 결정한다.
  * 1. 프로젝트에 .relay/가 있으면 → projectPath/.relay/
@@ -18,3 +47,4 @@ export declare function resolveRelayDir(projectPath: string, slug?: string): str
  */
 export declare function initGlobalAgentHome(slug: string, yamlData: Record<string, unknown>): string;
 export declare function registerPackage(program: Command): void;
+export {};

package/dist/commands/package.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeContentsDiff = computeContentsDiff;
+exports.syncContentsToRelay = syncContentsToRelay;
 exports.resolveRelayDir = resolveRelayDir;
 exports.initGlobalAgentHome = initGlobalAgentHome;
 exports.registerPackage = registerPackage;

package/dist/mcp/server.js

@@ -23,18 +23,18 @@ const js_yaml_1 = __importDefault(require("js-yaml"));
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = require('../../package.json');
 // ─── Helpers ───
-async function resolveUsername(token) {
+async function resolveUserInfo(token) {
     try {
         const res = await fetch(`${config_js_1.API_URL}/api/auth/me`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         if (!res.ok)
-            return undefined;
+            return {};
         const body = await res.json();
-        return body.username;
+        return { username: body.username, email: body.email };
     }
     catch {
-        return undefined;
+        return {};
     }
 }
 function countFiles(dir) {
@@ -208,8 +208,12 @@ function createMcpServer() {
         const projectPath = resolveMcpProjectPath(project_path);
         const token = await (0, config_js_1.getValidToken)();
         let username;
-        if (token)
-            username = await resolveUsername(token);
+        let email;
+        if (token) {
+            const info = await resolveUserInfo(token);
+            username = info.username;
+            email = info.email;
+        }
         const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
         const mounted = (0, ai_tools_js_1.detectMountedCLIs)();
         const relayYaml = path_1.default.join(projectPath, '.relay', 'relay.yaml');
@@ -226,7 +230,7 @@ function createMcpServer() {
         const cliUpdate = await checkCliVersion(true);
         return { content: [jsonText({
                     cli: { version: pkg.version, update_available: cliUpdate ? cliUpdate.latest : null },
-                    login: { authenticated: !!token, username },
+                    login: { authenticated: !!token, username, email },
                     agent_clis: detected.map((t) => t.name),
                     mounted_paths: mounted.map((m) => m.basePath),
                     project,
@@ -291,6 +295,108 @@ function createMcpServer() {
         }
         return { content: [jsonText({ sources })] };
     });
+    server.tool('relay_package', '소스 디렉토리에서 .relay/로 콘텐츠를 패키징합니다. mode: init(최초 소스 탐색), sync(변경 반영), migrate(source→contents 마이그레이션)', {
+        mode: zod_1.z.enum(['init', 'sync', 'migrate']).describe('패키징 모드'),
+        project_path: zod_1.z.string().optional().describe('프로젝트 경로'),
+    }, async ({ mode, project_path }) => {
+        try {
+            const projectPath = resolveMcpProjectPath(project_path);
+            const homeDir = (0, paths_js_1.resolveHome)();
+            const relayDir = path_1.default.join(projectPath, '.relay');
+            const relayYamlPath = path_1.default.join(relayDir, 'relay.yaml');
+            if (mode === 'init') {
+                // 최초 패키징: 소스 탐색
+                const { detectGlobalCLIs } = await import('../lib/ai-tools.js');
+                const localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+                const globalTools = detectGlobalCLIs(homeDir);
+                const sources = [];
+                for (const tool of localTools) {
+                    const items = (0, ai_tools_js_1.scanLocalItems)(projectPath, tool);
+                    if (items.length > 0)
+                        sources.push({ path: tool.skillsDir, location: 'local', name: tool.name, items: items.map((i) => ({ name: i.name, type: i.type, relativePath: i.relativePath })) });
+                }
+                for (const tool of globalTools) {
+                    const items = (0, ai_tools_js_1.scanGlobalItems)(tool, homeDir);
+                    if (items.length > 0)
+                        sources.push({ path: `~/${tool.skillsDir}`, location: 'global', name: `${tool.name} (global)`, items: items.map((i) => ({ name: i.name, type: i.type, relativePath: i.relativePath })) });
+                }
+                for (const { tool, basePath } of (0, ai_tools_js_1.detectMountedCLIs)()) {
+                    const items = (0, ai_tools_js_1.scanMountedItems)(basePath, tool);
+                    if (items.length > 0)
+                        sources.push({ path: `${basePath}/${tool.skillsDir}`, location: 'mounted', name: `${tool.name} (mounted)`, items: items.map((i) => ({ name: i.name, type: i.type, relativePath: i.relativePath })) });
+                }
+                // 기존 글로벌 에이전트 패키지 스캔
+                const globalAgentsDir = path_1.default.join(homeDir, '.relay', 'agents');
+                const existingAgents = [];
+                if (fs_1.default.existsSync(globalAgentsDir)) {
+                    for (const entry of fs_1.default.readdirSync(globalAgentsDir, { withFileTypes: true })) {
+                        if (!entry.isDirectory() || entry.name.startsWith('.'))
+                            continue;
+                        const agentYaml = path_1.default.join(globalAgentsDir, entry.name, 'relay.yaml');
+                        if (fs_1.default.existsSync(agentYaml)) {
+                            try {
+                                const cfg = js_yaml_1.default.load(fs_1.default.readFileSync(agentYaml, 'utf-8'));
+                                existingAgents.push({ slug: cfg.slug ?? entry.name, name: cfg.name ?? entry.name, version: cfg.version ?? '0.0.0', path: `~/.relay/agents/${entry.name}` });
+                            }
+                            catch { /* skip */ }
+                        }
+                    }
+                }
+                return { content: [jsonText({ status: 'init_required', sources, existing_agents: existingAgents })] };
+            }
+            // sync / migrate는 relay.yaml이 필요
+            if (!fs_1.default.existsSync(relayYamlPath)) {
+                return { content: [jsonText({ error: 'NOT_INITIALIZED', message: '.relay/relay.yaml이 없습니다. mode: init으로 먼저 실행하세요.' })], isError: true };
+            }
+            if (mode === 'migrate') {
+                const yamlMigrate = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
+                const cfgMigrate = js_yaml_1.default.load(yamlMigrate);
+                if (cfgMigrate.contents) {
+                    return { content: [jsonText({ status: 'already_migrated', message: '이미 contents 형식입니다.' })] };
+                }
+                const legacySource = cfgMigrate.source;
+                if (!legacySource) {
+                    return { content: [jsonText({ status: 'no_source', message: 'source 필드가 없습니다.' })], isError: true };
+                }
+                const localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+                const tool = localTools.find((t) => t.skillsDir === legacySource);
+                const migratedContents = [];
+                if (tool) {
+                    const items = (0, ai_tools_js_1.scanLocalItems)(projectPath, tool);
+                    for (const item of items) {
+                        migratedContents.push({ name: item.name, type: item.type, from: `${legacySource}/${item.relativePath}` });
+                    }
+                }
+                delete cfgMigrate.source;
+                cfgMigrate.contents = migratedContents;
+                fs_1.default.writeFileSync(relayYamlPath, js_yaml_1.default.dump(cfgMigrate, { lineWidth: 120 }), 'utf-8');
+                return { content: [jsonText({ status: 'migrated', contents: migratedContents })] };
+            }
+            // mode === 'sync'
+            const { computeContentsDiff, syncContentsToRelay } = await import('../commands/package.js');
+            const yamlContent = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
+            const config = js_yaml_1.default.load(yamlContent);
+            const contents = config.contents ?? [];
+            if (contents.length === 0) {
+                return { content: [jsonText({ status: 'no_contents', message: 'relay.yaml에 contents가 없습니다.' })], isError: true };
+            }
+            const { diff: contentsDiff, newItems } = computeContentsDiff(contents, relayDir, projectPath);
+            const hasChanges = contentsDiff.some((d) => d.status === 'modified');
+            if (hasChanges) {
+                syncContentsToRelay(contents, contentsDiff, relayDir, projectPath);
+            }
+            const summary = {
+                modified: contentsDiff.filter((d) => d.status === 'modified').length,
+                unchanged: contentsDiff.filter((d) => d.status === 'unchanged').length,
+                source_missing: contentsDiff.filter((d) => d.status === 'source_missing').length,
+                new_available: newItems.length,
+            };
+            return { content: [jsonText({ diff: contentsDiff, new_items: newItems, synced: hasChanges, summary })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
     server.tool('relay_org_list', '소속 Organization 목록을 조회합니다', {}, async () => {
         try {
             const token = await (0, config_js_1.getValidToken)();
@@ -522,8 +628,8 @@ function createMcpServer() {
             // 이미 로그인되어 있는지 확인
             const existingToken = await (0, config_js_1.getValidToken)();
             if (existingToken) {
-                const username = await resolveUsername(existingToken);
-                return { content: [jsonText({ status: 'already_authenticated', username })] };
+                const { username, email } = await resolveUserInfo(existingToken);
+                return { content: [jsonText({ status: 'already_authenticated', username, email })] };
             }
             // Device code 발급
             const res = await fetch(`${config_js_1.API_URL}/api/auth/device/request`, { method: 'POST' });
@@ -561,8 +667,8 @@ function createMcpServer() {
                         refresh_token: data.refresh_token,
                         expires_at: data.expires_at ? Number(data.expires_at) : undefined,
                     });
-                    const username = await resolveUsername(data.token);
-                    return { content: [jsonText({ status: 'ok', message: '로그인 완료', username })] };
+                    const { username, email } = await resolveUserInfo(data.token);
+                    return { content: [jsonText({ status: 'ok', message: '로그인 완료', username, email })] };
                 }
             }
             return { content: [jsonText({ status: 'timeout', verification_url, user_code, message: `브라우저에서 ${verification_url} 을 열고 코드 ${user_code} 를 입력해주세요.` })], isError: true };

package/dist/prompts/_setup-environment.md

@@ -59,6 +59,9 @@ cat ~/Library/Application\ Support/Claude/claude_desktop_config.json 2>/dev/null
 | "relay install X" | `relay install X` | `relay_install` tool 호출 (`slug: "X"`) |
 | "relay publish" | `relay publish` | `relay_publish` tool 호출 |
 | "relay login" | `relay login` | `relay_login` tool 호출 |
+| "relay package --init" | `relay package --init --json` | `relay_package` tool 호출 (`mode: "init"`) |
+| "relay package --sync" | `relay package --sync --json` | `relay_package` tool 호출 (`mode: "sync"`) |
+| "relay package --migrate" | `relay package --migrate --json` | `relay_package` tool 호출 (`mode: "migrate"`) |
 | "relay scan" | `relay package --init` | `relay_scan` tool 호출 |
 | "relay check-update X" | `relay check-update X` | `relay_check_update` tool 호출 (`slug: "X"`) |
 | "relay orgs list" | `relay orgs list --json` | `relay_org_list` tool 호출 |

package/dist/prompts/publish.md

@@ -28,6 +28,13 @@
 
 #### A. 최초 배포 (.relay/relay.yaml이 없음)
 
+**환경 B (MCP)의 경우:**
+`relay_package` MCP tool (`mode: "init"`)을 사용합니다. CLI의 `relay package --init --json`과 동일한 결과를 반환합니다.
+- 결과의 `sources[]`는 배포할 콘텐츠 **후보** 목록입니다. 전부 배포 대상이 아닙니다.
+- 사용자에게 어떤 콘텐츠를 패키지에 포함할지 반드시 물어보세요.
+
+**환경 A (터미널)의 경우:**
+
 ##### 1단계: 소스 탐색
 
 `relay package --init --json` 실행
@@ -172,6 +179,14 @@ contents:
 
 #### B. 재배포 (.relay/relay.yaml이 있음)
 
+**환경 B (MCP)의 경우:**
+`relay_package` MCP tool을 사용합니다:
+- `mode: "migrate"` — B-0 마이그레이션 (source → contents)
+- `mode: "sync"` — B-1~B-2 동기화 + 변경 반영
+- sync 결과의 `new_items`가 있으면 B-3 새 콘텐츠 추가도 진행합니다.
+
+**환경 A (터미널)의 경우:**
+
 ##### B-0. 기존 source 필드 마이그레이션
 
 relay.yaml에 기존 `source` 필드만 있고 `contents`가 없으면:
@@ -276,7 +291,11 @@ Organization 목록을 조회합니다:
   - question: "Organization이 없습니다. 비공개 배포를 하려면 Organization이 필요합니다. Organization을 만들까요?"
   - options: `["Organization 생성", "Organization 없이 계속 (공개/링크공유만 가능)"]`
 - "Organization 생성" 선택 시:
-  - **사용자 질문 도구 호출:** question: "Organization 이름을 입력하세요."
+  - 로그인 정보(username, email)를 기반으로 Organization 이름을 추천합니다:
+    - 업무용 이메일(커스텀 도메인)이면 → 도메인에서 회사명 추출하여 추천. 예: `haemin@relayax.com` → "relayax"
+    - 비업무용 이메일(gmail.com, naver.com, kakao.com, daum.net, hotmail.com, outlook.com, yahoo.com, icloud.com 등 무료 메일)이면 → username을 추천. 예: `haemin` → "haemin"
+    - email이 없으면 → username을 추천
+  - **사용자 질문 도구 호출:** question: "Organization 이름을 입력하세요. (추천: {추천이름})"
   - 환경 A: `relay orgs create "이름" --json` 실행
   - 환경 B: `relay_org_create` MCP tool 호출
   - 생성 후 org 목록을 갱신합니다.
@@ -300,18 +319,19 @@ relay.yaml의 `visibility` 설정을 확인합니다.
 
 Org가 선택된 경우:
 - **사용자 질문 도구 호출:**
-  - question: "공개 범위를 선택하세요"
-  - options: `["공개 — 누구나 설치", "링크 공유 — 접근 링크가 있는 사람만 설치", "비공개 — Org 멤버만"]`
+  - question: "{org_name} Organization에 배포합니다. 공개 범위를 선택하세요"
+  - options: `["public — 외부인 포함 누구나 설치", "internal — 조직 구성원 누구나 설치", "private — 조직 내에서도 허가받은 사람만 설치"]`
 
-Org가 없는 경우:
+Org가 없는 경우 (개인 배포):
 - **사용자 질문 도구 호출:**
   - question: "공개 범위를 선택하세요"
-  - options: `["공개 — 누구나 설치", "링크 공유 — 접근 링크가 있는 사람만 설치"]`
+  - options: `["public — 누구나 검색하여 설치 가능", "private — 접근 링크를 받은 사람만 설치 가능"]`
 
 **응답 처리:**
-- "공개" → relay.yaml에 `visibility: public` 저장
-- "링크 공유" → relay.yaml에 `visibility: private` 저장. 배포 후 웹 대시보드(/dashboard)에서 접근 링크를 생성하고 구매 안내를 설정할 수 있다고 안내.
-- "비공개" → relay.yaml에 `visibility: internal`, `org: <selected_slug>` 저장
+
+- "public" → relay.yaml에 `visibility: public` 저장
+- "internal" → relay.yaml에 `visibility: internal` 저장
+- "private" → relay.yaml에 `visibility: private` 저장. 배포 후 웹 대시보드에서 접근 코드를 생성하여 공유할 수 있다고 안내.
 
 **재배포 (visibility 이미 설정됨):**
 
@@ -325,12 +345,21 @@ Org가 없는 경우:
 
 .relay/ 내 모든 파일을 자동 분석합니다.
 
-#### 2-1. 시크릿 스캔 (자동)
+#### 2-1. 시크릿 & 개인정보 스캔 (자동)
+
+**시크릿 스캔:**
 - 하드코딩된 API 키, 토큰, 비밀번호, Private Key 등을 탐색합니다.
   - 예: sk-..., ghp_..., AKIA..., Bearer 토큰, JWT, -----BEGIN PRIVATE KEY----- 등
 - 발견 시 **즉시 사용자에게 경고**하고, 환경변수로 대체하도록 안내합니다.
 - 시크릿이 제거되지 않으면 배포를 진행하지 않습니다.
 
+**개인정보 스캔:**
+- 이메일 주소, 전화번호, 실명, 주소 등 개인정보가 포함된 파일을 탐색합니다.
+- **중요: 패키지에 포함된 모든 파일은 설치한 사람이 볼 수 있습니다.** 상세페이지에 노출되지 않더라도 패키지 자체에 포함됩니다.
+- 발견 시 사용자에게 경고하고 제거/수정 여부를 확인받습니다:
+  - "⚠ {파일명}에 개인정보({종류})가 포함되어 있습니다. 이 파일은 패키지에 포함되어 설치한 사람이 볼 수 있습니다."
+  - **사용자 질문 도구 호출:** question: "개인정보가 포함된 파일을 어떻게 처리할까요?", options: `["제거 후 배포", "그대로 배포", "취소"]`
+
 #### 2-2. 환경변수 & 의존성 분석 (자동)
 분석 대상:
 - **env**: 환경변수 참조 (process.env.*, ${VAR}, os.environ 등)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayax-cli",
-  "version": "0.3.58",
+  "version": "0.3.61",
   "description": "RelayAX Agent Team Marketplace CLI - Install and manage agent teams",
   "main": "dist/index.js",
   "bin": {