relayax-cli 0.3.58 → 0.3.59

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

@@ -291,6 +291,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)();

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`가 없으면:
@@ -300,18 +315,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 이미 설정됨):**
 

package/package.json

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