relayax-cli 0.3.57 → 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/index.js

@@ -15,7 +15,6 @@ const login_js_1 = require("./commands/login.js");
 const update_js_1 = require("./commands/update.js");
 const outdated_js_1 = require("./commands/outdated.js");
 const check_update_js_1 = require("./commands/check-update.js");
-const follow_js_1 = require("./commands/follow.js");
 const changelog_js_1 = require("./commands/changelog.js");
 const join_js_1 = require("./commands/join.js");
 const orgs_js_1 = require("./commands/orgs.js");
@@ -48,7 +47,6 @@ program
 (0, update_js_1.registerUpdate)(program);
 (0, outdated_js_1.registerOutdated)(program);
 (0, check_update_js_1.registerCheckUpdate)(program);
-(0, follow_js_1.registerFollow)(program);
 (0, changelog_js_1.registerChangelog)(program);
 (0, join_js_1.registerJoin)(program);
 (0, orgs_js_1.registerOrgs)(program);

package/dist/mcp/server.js

@@ -79,6 +79,18 @@ async function getCliUpdateWarning() {
 function jsonTextWithUpdate(obj, update) {
     return jsonText(update ? { ...obj, ...update } : obj);
 }
+// MCP 서버는 Claude Desktop이 spawn하므로 cwd가 / 등 예측 불가한 경로일 수 있다.
+// project_path가 없을 때 cwd 대신 홈 디렉토리를 fallback으로 사용한다.
+const os_1 = __importDefault(require("os"));
+function resolveMcpProjectPath(projectPath) {
+    if (projectPath)
+        return projectPath;
+    const resolved = (0, paths_js_1.resolveProjectPath)();
+    // cwd가 / 또는 비정상적이면 홈 디렉토리 사용
+    if (resolved === '/' || resolved === '')
+        return os_1.default.homedir();
+    return resolved;
+}
 // ─── Server ───
 function createMcpServer() {
     const server = new mcp_js_1.McpServer({ name: 'relay', version: pkg.version }, { capabilities: { tools: {}, prompts: {} } });
@@ -97,10 +109,10 @@ function createMcpServer() {
     });
     server.tool('relay_install', '에이전트를 설치합니다', {
         slug: zod_1.z.string().describe('에이전트 slug (예: @owner/name)'),
-        project_path: zod_1.z.string().optional().describe('프로젝트 경로 (기본: cwd)'),
+        project_path: zod_1.z.string().optional().describe('프로젝트 경로 (기본: 홈 디렉토리)'),
     }, async ({ slug: slugInput, project_path }) => {
         try {
-            const projectPath = project_path ?? (0, paths_js_1.resolveProjectPath)();
+            const projectPath = resolveMcpProjectPath(project_path);
             const token = await (0, config_js_1.getValidToken)();
             const parsed = await (0, slug_js_1.resolveSlug)(slugInput);
             const fullSlug = parsed.full;
@@ -124,8 +136,27 @@ function createMcpServer() {
                 (0, config_js_1.saveInstalled)(installed);
                 await (0, api_js_1.reportInstall)(agent.id, fullSlug, agent.version);
                 (0, api_js_1.sendUsagePing)(agent.id, fullSlug, agent.version);
+                // relay.yaml에서 tags, requires 읽기 (scope 판단용)
+                let agentTags = [];
+                let agentRequires = null;
+                let hasRules = false;
+                try {
+                    const relayYamlPath = path_1.default.join(agentDir, 'relay.yaml');
+                    if (fs_1.default.existsSync(relayYamlPath)) {
+                        const cfg = js_yaml_1.default.load(fs_1.default.readFileSync(relayYamlPath, 'utf-8'));
+                        agentTags = cfg.tags ?? [];
+                        agentRequires = cfg.requires ?? null;
+                    }
+                    hasRules = fs_1.default.existsSync(path_1.default.join(agentDir, 'rules')) && fs_1.default.readdirSync(path_1.default.join(agentDir, 'rules')).length > 0;
+                }
+                catch { /* non-critical */ }
                 const cliUpdate = await getCliUpdateWarning();
-                return { content: [jsonTextWithUpdate({ status: 'ok', agent: agent.name, slug: fullSlug, version: agent.version, files: countFiles(agentDir), install_path: agentDir }, cliUpdate)] };
+                return { content: [jsonTextWithUpdate({
+                            status: 'ok', agent: agent.name, slug: fullSlug, version: agent.version,
+                            description: agent.description ?? '', tags: agentTags, requires: agentRequires, has_rules: hasRules,
+                            files: countFiles(agentDir), install_path: agentDir,
+                            scope_hint: '설치 후 에이전트 성격에 따라 글로벌/로컬 배치를 사용자에게 물어보세요. tags에 특정 프레임워크가 있거나 rules/가 있으면 로컬 추천, 범용이면 글로벌 추천.',
+                        }, cliUpdate)] };
             }
             finally {
                 (0, storage_js_1.removeTempDir)(tempDir);
@@ -174,7 +205,7 @@ function createMcpServer() {
     server.tool('relay_status', '현재 relay 환경 상태를 표시합니다', {
         project_path: zod_1.z.string().optional().describe('프로젝트 경로'),
     }, async ({ project_path }) => {
-        const projectPath = project_path ?? (0, paths_js_1.resolveProjectPath)();
+        const projectPath = resolveMcpProjectPath(project_path);
         const token = await (0, config_js_1.getValidToken)();
         let username;
         if (token)
@@ -236,7 +267,7 @@ function createMcpServer() {
     server.tool('relay_scan', '배포 가능한 스킬/에이전트/커맨드를 스캔합니다', {
         project_path: zod_1.z.string().optional().describe('프로젝트 경로'),
     }, async ({ project_path }) => {
-        const projectPath = project_path ?? (0, paths_js_1.resolveProjectPath)();
+        const projectPath = resolveMcpProjectPath(project_path);
         const homeDir = (0, paths_js_1.resolveHome)();
         const sources = [];
         // 로컬
@@ -260,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)();
@@ -310,7 +443,7 @@ function createMcpServer() {
         project_path: zod_1.z.string().optional().describe('프로젝트 경로 (.relay/relay.yaml이 있는 디렉토리)'),
     }, async ({ project_path }) => {
         try {
-            const projectPath = project_path ?? (0, paths_js_1.resolveProjectPath)();
+            const projectPath = resolveMcpProjectPath(project_path);
             const relayDir = path_1.default.join(projectPath, '.relay');
             const relayYaml = path_1.default.join(relayDir, 'relay.yaml');
             if (!fs_1.default.existsSync(relayYaml)) {
@@ -349,6 +482,142 @@ function createMcpServer() {
             return { content: [jsonText({ error: String(err) })], isError: true };
         }
     });
+    // ═══ grant / access / join ═══
+    server.tool('relay_grant_create', '에이전트 또는 Organization의 접근 코드를 생성합니다', {
+        agent_slug: zod_1.z.string().optional().describe('에이전트 slug (agent 접근 코드 생성 시)'),
+        org_slug: zod_1.z.string().optional().describe('Organization slug (org 접근 코드 생성 시)'),
+        max_uses: zod_1.z.number().optional().describe('최대 사용 횟수'),
+        expires_at: zod_1.z.string().optional().describe('만료일 (ISO 8601)'),
+    }, async ({ agent_slug, org_slug, max_uses, expires_at }) => {
+        try {
+            if (!agent_slug && !org_slug) {
+                return { content: [jsonText({ error: 'MISSING_OPTION', message: 'agent_slug 또는 org_slug가 필요합니다.' })], isError: true };
+            }
+            const token = await (0, config_js_1.getValidToken)();
+            if (!token)
+                return { content: [jsonText({ error: 'LOGIN_REQUIRED', message: '로그인이 필요합니다.' })], isError: true };
+            let agentId;
+            let orgId;
+            if (agent_slug) {
+                const res = await fetch(`${config_js_1.API_URL}/api/agents/${agent_slug}`, { headers: { Authorization: `Bearer ${token}` } });
+                if (!res.ok)
+                    throw new Error('에이전트를 찾을 수 없습니다.');
+                agentId = (await res.json()).id;
+            }
+            if (org_slug) {
+                const res = await fetch(`${config_js_1.API_URL}/api/orgs/${org_slug}`, { headers: { Authorization: `Bearer ${token}` } });
+                if (!res.ok)
+                    throw new Error('Organization을 찾을 수 없습니다.');
+                orgId = (await res.json()).id;
+            }
+            const { createAccessCode } = await import('../commands/grant.js');
+            const result = await createAccessCode({
+                type: agentId ? 'agent' : 'org',
+                agent_id: agentId,
+                org_id: orgId,
+                max_uses,
+                expires_at,
+            });
+            return { content: [jsonText({ status: 'created', ...result })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    server.tool('relay_grant_use', '접근 코드를 사용하여 org 가입 또는 에이전트 접근 권한을 획득합니다', {
+        code: zod_1.z.string().describe('접근 코드'),
+    }, async ({ code }) => {
+        try {
+            const { useAccessCode } = await import('../commands/grant.js');
+            const result = await useAccessCode(code);
+            return { content: [jsonText({ ...result, status: 'ok' })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    server.tool('relay_access', '접근 코드로 비공개 에이전트 접근 권한을 획득합니다 (설치는 별도로 relay_install 호출 필요)', {
+        slug: zod_1.z.string().describe('에이전트 slug'),
+        code: zod_1.z.string().describe('접근 코드'),
+    }, async ({ slug: slugInput, code }) => {
+        try {
+            const token = await (0, config_js_1.getValidToken)();
+            if (!token)
+                return { content: [jsonText({ error: 'LOGIN_REQUIRED', message: '로그인이 필요합니다.' })], isError: true };
+            const res = await fetch(`${config_js_1.API_URL}/api/agents/${slugInput}/claim-access`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+                body: JSON.stringify({ code }),
+            });
+            if (!res.ok) {
+                const body = await res.json().catch(() => ({}));
+                throw new Error(body.message ?? `접근 권한 획득 실패 (${res.status})`);
+            }
+            const result = await res.json();
+            return { content: [jsonText({ status: 'ok', ...result })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    server.tool('relay_join', '초대 코드로 Organization에 가입합니다', {
+        code: zod_1.z.string().describe('초대 코드 (UUID)'),
+    }, async ({ code }) => {
+        try {
+            const { useAccessCode } = await import('../commands/grant.js');
+            const result = await useAccessCode(code);
+            return { content: [jsonText({ ...result, status: 'ok' })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    // ═══ relay_deploy_record — 배치 파일 기록 ═══
+    server.tool('relay_deploy_record', '에이전트 파일 배치 정보를 installed.json에 기록합니다', {
+        slug: zod_1.z.string().describe('에이전트 slug'),
+        scope: zod_1.z.enum(['global', 'local']).describe('배치 범위 (global 또는 local)'),
+        files: zod_1.z.array(zod_1.z.string()).optional().describe('배치된 파일 경로 목록'),
+    }, async ({ slug: slugInput, scope, files }) => {
+        try {
+            const { isScopedSlug, parseSlug } = await import('../lib/slug.js');
+            const localRegistry = (0, config_js_1.loadInstalled)();
+            const globalRegistry = (0, config_js_1.loadGlobalInstalled)();
+            let slug;
+            if (isScopedSlug(slugInput)) {
+                slug = slugInput;
+            }
+            else {
+                const allKeys = [...Object.keys(localRegistry), ...Object.keys(globalRegistry)];
+                const match = allKeys.find((key) => {
+                    const parsed = parseSlug(key);
+                    return parsed && parsed.name === slugInput;
+                });
+                slug = match ?? slugInput;
+            }
+            const entry = localRegistry[slug] ?? globalRegistry[slug];
+            if (!entry) {
+                return { content: [jsonText({ error: 'NOT_INSTALLED', message: `'${slugInput}'는 설치되어 있지 않습니다.` })], isError: true };
+            }
+            entry.deploy_scope = scope;
+            entry.deployed_files = files ?? [];
+            if (scope === 'global') {
+                globalRegistry[slug] = entry;
+                (0, config_js_1.saveGlobalInstalled)(globalRegistry);
+                if (localRegistry[slug]) {
+                    localRegistry[slug] = entry;
+                    (0, config_js_1.saveInstalled)(localRegistry);
+                }
+            }
+            else {
+                localRegistry[slug] = entry;
+                (0, config_js_1.saveInstalled)(localRegistry);
+            }
+            return { content: [jsonText({ status: 'ok', slug, deploy_scope: scope, deployed_files: (files ?? []).length })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
     // ═══ relay_login — device code 로그인 ═══
     server.tool('relay_login', 'Device Code 방식으로 로그인합니다. URL과 코드를 사용자에게 보여주고, 승인을 기다립니다.', {}, async () => {
         try {

package/dist/prompts/_setup-environment.md

@@ -59,9 +59,17 @@ 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 호출 |
 | "relay orgs create" | `relay orgs create "이름" --json` | `relay_org_create` tool 호출 (`name: "이름"`) |
+| "relay grant create" | `relay grant create --agent <slug>` | `relay_grant_create` tool 호출 (`agent_slug: "<slug>"`) |
+| "relay grant use" | `relay grant use --code <code>` | `relay_grant_use` tool 호출 (`code: "<code>"`) |
+| "relay access" | `relay access <slug> --code <code>` | `relay_access` tool 호출 (`slug`, `code`) |
+| "relay join" | `relay join <slug> --code <code>` | `relay_join` tool 호출 (`code: "<code>"`) |
+| "relay deploy-record" | `relay deploy-record <slug> --scope <scope> --files ...` | `relay_deploy_record` tool 호출 |
 
 처음 판별한 환경을 이후 계속 사용합니다.

package/dist/prompts/install.md

@@ -85,7 +85,9 @@ slug가 직접 주어지면 (`/relay-install @alice/doc-writer`) 이 단계를
   3. 코드가 있으면 `relay access <slug> --code <code>`를 실행합니다.
   4. 코드가 없으면 purchase_info의 url로 구매 안내합니다.
 
-#### 2-2. 배치 범위 선택 (추천 포함)
+#### 2-2. 배치 범위 선택 (필수 — 이 단계를 절대 건너뛰지 마세요)
+
+**반드시 사용자에게 글로벌/로컬 중 어디에 설치할지 물어보세요.** 에이전트 메타데이터(tags, requires 등)가 없어도 반드시 물어봐야 합니다. 메타데이터가 없으면 글로벌을 추천하되, 사용자 확인은 필수입니다.
 
 에이전트의 성격을 분석하여 글로벌/로컬 중 적합한 쪽을 추천합니다.
 
@@ -132,18 +134,7 @@ relay deploy-record <slug> --scope <global|local> --files <배치된_파일1> <
 
 #### 3-1. 완료 안내
 - 배치된 파일과 활성화된 커맨드 목록을 보여줍니다.
-#### 3-2. 팔로우 제안 (필수 — 이 단계를 절대 건너뛰지 마세요)
-빌더의 username이 JSON 결과에 있으면 **반드시** 사용자 질문 도구를 호출하세요.
-
-**사용자 질문 도구 호출:**
-- question: `@{username}을 팔로우할까요? 새 버전 알림을 받을 수 있습니다.`
-- options: `["팔로우", "건너뛰기"]`
-
-**응답 처리:**
-- "팔로우" → `relay follow @{username}` 실행. 로그인이 안 되어 있으면 `relay login` 먼저 실행 후 재시도.
-- "건너뛰기" → 다음 단계로 진행
-
-#### 3-3. 공유 가이드 (필수 — 설치 완료 시 반드시 표시)
+#### 3-2. 공유 가이드 (필수 — 설치 완료 시 반드시 표시)
 설치 완료 후 아래 공유용 설치 가이드를 표시합니다. 복사 가능한 코드 블록으로 보여줍니다.
 
 ```

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`가 없으면:
@@ -263,45 +278,64 @@ relay.yaml의 현재 `version`을 읽고 semver 범프를 제안합니다.
 - 유지 외 선택 → relay.yaml의 version을 선택된 값으로 업데이트
 - 유지 → 그대로 진행
 
-### Step 1. 공개 범위 선택
+### Step 1. Organization 선택 & 공개 범위 설정
 
-relay.yaml의 `visibility` 설정을 확인합니다.
+#### 1-1. Organization 확인 (먼저 실행)
 
-#### 신규 배포 (visibility 미설정)
+Organization 목록을 조회합니다:
+- 환경 A: `relay orgs list --json` 실행
+- 환경 B: `relay_org_list` MCP tool 호출
 
-**사용자 질문 도구 호출:**
-- question: "공개 범위를 선택하세요"
-- options: `["공개 — 누구나 설치", "링크 공유 — 접근 링크가 있는 사람만 설치", "비공개 — Org 멤버만"]`
+**Org가 0개이면:**
+- **사용자 질문 도구 호출:**
+  - question: "Organization이 없습니다. 비공개 배포를 하려면 Organization이 필요합니다. Organization을 만들까요?"
+  - options: `["Organization 생성", "Organization 없이 계속 (공개/링크공유만 가능)"]`
+- "Organization 생성" 선택 시:
+  - **사용자 질문 도구 호출:** question: "Organization 이름을 입력하세요."
+  - 환경 A: `relay orgs create "이름" --json` 실행
+  - 환경 B: `relay_org_create` MCP tool 호출
+  - 생성 후 org 목록을 갱신합니다.
+
+**Org가 1개 이상이면:**
+
+**사용자 질문 도구 호출 (Org가 1개여도 반드시 호출):**
+- question: "어떤 Organization에 배포할까요?"
+- options: `["<org1_name> (<org1_slug>)", "<org2_name> (<org2_slug>)", ..., "Organization 없이 배포 (공개/링크공유)"]`
+- **중요: Org가 1개라도 자동 선택하지 말고 반드시 사용자에게 확인받으세요.**
 
 **응답 처리:**
-- "공개" → relay.yaml에 `visibility: public` 저장
-- "링크 공유" → relay.yaml에 `visibility: private` 저장. 배포 후 웹 대시보드(/dashboard)에서 접근 링크를 생성하고 구매 안내를 설정할 수 있다고 안내.
-- "비공개" → Organization 목록을 조회합니다:
-  - 환경 A: `relay orgs list --json` 실행
-  - 환경 B: `relay_status` tool 응답을 참고하거나, 배포 시 `relay_publish` tool이 org 선택 없이 배포하면 서버가 자동 매칭합니다.
-  - Org가 0개이면: Organization을 생성합니다.
-    - 환경 A: `relay orgs create "이름" --json` 실행
-    - 환경 B: `relay_org_create` MCP tool 호출 (tool이 없으면 사용자에게 "www.relayax.com/orgs 에서 Organization을 생성하세요"라고 안내)
-    - **사용자 질문 도구 호출:**
-      - question: "비공개 배포를 위해 Organization을 만들어야 합니다. Organization 이름을 입력하세요."
-    - 생성 후 해당 org를 선택하여 계속 진행합니다.
+- Org 선택 → relay.yaml에 `org: <selected_slug>` 저장, 1-2단계로
+- "Organization 없이 배포" → org 없이 1-2단계로 (비공개 옵션 제외)
+
+#### 1-2. 공개 범위 선택
+
+relay.yaml의 `visibility` 설정을 확인합니다.
 
-  **사용자 질문 도구 호출 (Org가 1개여도 반드시 호출):**
-  - question: "어떤 Organization에 배포할까요?"
-  - options: `["<org1_name>", "<org2_name>", ...]`
-  - **중요: Org가 1개라도 자동 선택하지 말고 반드시 사용자에게 확인받으세요.**
+**신규 배포 (visibility 미설정):**
 
-  → relay.yaml에 `visibility: internal`, `org: <selected_slug>` 저장
+Org가 선택된 경우:
+- **사용자 질문 도구 호출:**
+  - question: "{org_name} Organization에 배포합니다. 공개 범위를 선택하세요"
+  - options: `["public — 외부인 포함 누구나 설치", "internal — 조직 구성원 누구나 설치", "private — 조직 내에서도 허가받은 사람만 설치"]`
+
+Org가 없는 경우 (개인 배포):
+- **사용자 질문 도구 호출:**
+  - question: "공개 범위를 선택하세요"
+  - options: `["public — 누구나 검색하여 설치 가능", "private — 접근 링크를 받은 사람만 설치 가능"]`
+
+**응답 처리:**
 
-#### 재배포 (visibility 이미 설정됨)
+- "public" → relay.yaml에 `visibility: public` 저장
+- "internal" → relay.yaml에 `visibility: internal` 저장
+- "private" → relay.yaml에 `visibility: private` 저장. 배포 후 웹 대시보드에서 접근 코드를 생성하여 공유할 수 있다고 안내.
 
-현재 설정을 확인합니다:
+**재배포 (visibility 이미 설정됨):**
 
 **사용자 질문 도구 호출:**
 - question: 공개일 때 "현재 **공개** 설정입니다. 유지할까요?", 링크공유일 때 "현재 **링크 공유** 설정입니다. 접근 링크가 있는 사람만 설치 가능합니다. 유지할까요?", 비공개일 때 "현재 **비공개** 설정입니다 (Org: {name}). 유지할까요?"
 - options: `["유지", "변경"]`
 
-"변경" → 신규 배포와 동일한 플로우
+"변경" → 1-1부터 다시 진행
 
 ### Step 2. 보안 점검 & requires 확인
 

package/package.json

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