relayax-cli 0.1.93 → 0.1.95

package/dist/commands/create.js

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const ai_tools_js_1 = require("../lib/ai-tools.js");
 const command_adapter_js_1 = require("../lib/command-adapter.js");
-const DEFAULT_DIRS = ['skills', 'commands'];
+const DEFAULT_DIRS = ['.relay/skills', '.relay/commands'];
 /**
  * 글로벌 User 커맨드가 없으면 설치한다.
  */
@@ -31,15 +31,16 @@ function registerCreate(program) {
         .action(async (name) => {
         const json = program.opts().json ?? false;
         const projectPath = process.cwd();
-        const relayYamlPath = path_1.default.join(projectPath, 'relay.yaml');
+        const relayDir = path_1.default.join(projectPath, '.relay');
+        const relayYamlPath = path_1.default.join(relayDir, 'relay.yaml');
         const isTTY = Boolean(process.stdin.isTTY) && !json;
-        // 1. relay.yaml 이미 존재하면 에러
+        // 1. .relay/relay.yaml 이미 존재하면 에러
         if (fs_1.default.existsSync(relayYamlPath)) {
             if (json) {
-                console.error(JSON.stringify({ error: 'ALREADY_EXISTS', message: 'relay.yaml이 이미 존재합니다.' }));
+                console.error(JSON.stringify({ error: 'ALREADY_EXISTS', message: '.relay/relay.yaml이 이미 존재합니다.' }));
             }
             else {
-                console.error('relay.yaml이 이미 존재합니다. 기존 팀 프로젝트에서는 `relay init`을 사용하세요.');
+                console.error('.relay/relay.yaml이 이미 존재합니다. 기존 팀 프로젝트에서는 `relay init`을 사용하세요.');
             }
             process.exit(1);
         }
@@ -69,7 +70,8 @@ function registerCreate(program) {
                 ],
             });
         }
-        // 3. relay.yaml 생성
+        // 3. .relay/relay.yaml 생성
+        fs_1.default.mkdirSync(relayDir, { recursive: true });
         const yamlData = {
             name,
             slug: defaultSlug,
@@ -118,7 +120,7 @@ function registerCreate(program) {
         }
         else {
             console.log(`\n\x1b[32m✓ ${name} 팀 프로젝트 생성 완료\x1b[0m\n`);
-            console.log(`  relay.yaml 생성됨`);
+            console.log(`  .relay/relay.yaml 생성됨`);
             if (createdDirs.length > 0) {
                 console.log(`  디렉토리 생성: ${createdDirs.join(', ')}`);
             }

package/dist/commands/init.js

@@ -77,19 +77,103 @@ function hasGlobalUserCommands() {
     return command_adapter_js_1.USER_COMMANDS.every((cmd) => fs_1.default.existsSync((0, command_adapter_js_1.getGlobalCommandPath)(cmd.id)));
 }
 /**
- * 팀 프로젝트인지 감지한다 (relay.yaml 또는 팀 디렉토리 구조).
+ * 팀 프로젝트인지 감지한다 (.relay/ 디렉토리 내 relay.yaml 또는 팀 디렉토리 구조).
  */
 function isTeamProject(projectPath) {
-    if (fs_1.default.existsSync(path_1.default.join(projectPath, 'relay.yaml'))) {
+    const relayDir = path_1.default.join(projectPath, '.relay');
+    if (!fs_1.default.existsSync(relayDir))
+        return false;
+    if (fs_1.default.existsSync(path_1.default.join(relayDir, 'relay.yaml'))) {
         return true;
     }
     return VALID_TEAM_DIRS.some((d) => {
-        const dirPath = path_1.default.join(projectPath, d);
+        const dirPath = path_1.default.join(relayDir, d);
         if (!fs_1.default.existsSync(dirPath))
             return false;
         return fs_1.default.readdirSync(dirPath).filter((f) => !f.startsWith('.')).length > 0;
     });
 }
+/** 레거시 User 커맨드 ID (이전에 로컬에 설치되던 것) */
+const LEGACY_LOCAL_COMMAND_IDS = ['relay-explore', 'relay-install', 'relay-publish'];
+/**
+ * 레거시 구조를 감지하고 마이그레이션한다.
+ * - relay.yaml (루트) → .relay/relay.yaml
+ * - portfolio/ (루트) → .relay/portfolio/
+ * - 로컬 레거시 슬래시 커맨드 제거 (글로벌로 이동되므로)
+ */
+/** 루트에 있으면 .relay/ 안으로 옮길 디렉토리 */
+const LEGACY_CONTENT_DIRS = ['skills', 'agents', 'rules', 'commands', 'portfolio'];
+function detectLegacy(projectPath) {
+    const details = [];
+    if (fs_1.default.existsSync(path_1.default.join(projectPath, 'relay.yaml'))) {
+        details.push('relay.yaml → .relay/relay.yaml');
+    }
+    for (const dir of LEGACY_CONTENT_DIRS) {
+        const legacyDir = path_1.default.join(projectPath, dir);
+        if (fs_1.default.existsSync(legacyDir) && fs_1.default.statSync(legacyDir).isDirectory()) {
+            const hasFiles = fs_1.default.readdirSync(legacyDir).filter((f) => !f.startsWith('.')).length > 0;
+            if (hasFiles) {
+                details.push(`${dir}/ → .relay/${dir}/`);
+            }
+        }
+    }
+    // 로컬에 레거시 슬래시 커맨드가 있는지 확인
+    const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+    for (const tool of detected) {
+        const cmdDir = path_1.default.join(projectPath, tool.skillsDir, 'commands', 'relay');
+        if (!fs_1.default.existsSync(cmdDir))
+            continue;
+        for (const cmdId of LEGACY_LOCAL_COMMAND_IDS) {
+            if (fs_1.default.existsSync(path_1.default.join(cmdDir, `${cmdId}.md`))) {
+                details.push(`${tool.skillsDir}/commands/relay/ 레거시 커맨드 정리`);
+                break;
+            }
+        }
+    }
+    return { hasLegacy: details.length > 0, details };
+}
+function runMigration(projectPath) {
+    const result = { relayYaml: false, portfolio: false, localCommandsCleaned: 0 };
+    const relayDir = path_1.default.join(projectPath, '.relay');
+    fs_1.default.mkdirSync(relayDir, { recursive: true });
+    // 1. relay.yaml 이동
+    const legacyYaml = path_1.default.join(projectPath, 'relay.yaml');
+    const newYaml = path_1.default.join(relayDir, 'relay.yaml');
+    if (fs_1.default.existsSync(legacyYaml) && !fs_1.default.existsSync(newYaml)) {
+        fs_1.default.renameSync(legacyYaml, newYaml);
+        result.relayYaml = true;
+    }
+    // 2. 콘텐츠 디렉토리 이동 (skills, agents, rules, commands, portfolio)
+    for (const dir of LEGACY_CONTENT_DIRS) {
+        const legacyDir = path_1.default.join(projectPath, dir);
+        const newDir = path_1.default.join(relayDir, dir);
+        if (fs_1.default.existsSync(legacyDir) && fs_1.default.statSync(legacyDir).isDirectory() && !fs_1.default.existsSync(newDir)) {
+            fs_1.default.renameSync(legacyDir, newDir);
+            if (dir === 'portfolio')
+                result.portfolio = true;
+        }
+    }
+    // 3. 로컬 레거시 슬래시 커맨드 제거
+    const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+    for (const tool of detected) {
+        const cmdDir = path_1.default.join(projectPath, tool.skillsDir, 'commands', 'relay');
+        if (!fs_1.default.existsSync(cmdDir))
+            continue;
+        for (const cmdId of LEGACY_LOCAL_COMMAND_IDS) {
+            const cmdPath = path_1.default.join(cmdDir, `${cmdId}.md`);
+            if (fs_1.default.existsSync(cmdPath)) {
+                fs_1.default.unlinkSync(cmdPath);
+                result.localCommandsCleaned++;
+            }
+        }
+        // 디렉토리가 비었으면 삭제
+        const remaining = fs_1.default.readdirSync(cmdDir);
+        if (remaining.length === 0) {
+            fs_1.default.rmdirSync(cmdDir);
+        }
+    }
+    return result;
+}
 function registerInit(program) {
     program
         .command('init')
@@ -99,6 +183,42 @@ function registerInit(program) {
         .action(async (opts) => {
         const json = program.opts().json ?? false;
         const projectPath = process.cwd();
+        // ── 0. 레거시 마이그레이션 ──
+        const legacy = detectLegacy(projectPath);
+        let migrated = false;
+        if (legacy.hasLegacy) {
+            if (json) {
+                // JSON 모드: 자동 마이그레이션
+                const migrationResult = runMigration(projectPath);
+                migrated = migrationResult.relayYaml || migrationResult.portfolio || migrationResult.localCommandsCleaned > 0;
+            }
+            else if (process.stdin.isTTY) {
+                console.log('\n  \x1b[33m⚠ 레거시 구조 감지\x1b[0m\n');
+                for (const d of legacy.details) {
+                    console.log(`    ${d}`);
+                }
+                console.log();
+                const { confirm } = await import('@inquirer/prompts');
+                const doMigrate = await confirm({ message: '마이그레이션할까요?', default: true });
+                if (doMigrate) {
+                    const migrationResult = runMigration(projectPath);
+                    migrated = true;
+                    console.log(`\n  \x1b[32m✓ 마이그레이션 완료\x1b[0m`);
+                    if (migrationResult.relayYaml)
+                        console.log('    relay.yaml → .relay/relay.yaml');
+                    if (migrationResult.portfolio)
+                        console.log('    portfolio/ → .relay/portfolio/');
+                    if (migrationResult.localCommandsCleaned > 0)
+                        console.log(`    레거시 로컬 커맨드 ${migrationResult.localCommandsCleaned}개 제거`);
+                    console.log();
+                }
+            }
+            else {
+                // 비TTY, 비JSON: 자동 마이그레이션
+                const migrationResult = runMigration(projectPath);
+                migrated = migrationResult.relayYaml || migrationResult.portfolio || migrationResult.localCommandsCleaned > 0;
+            }
+        }
         const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
         const detectedIds = new Set(detected.map((t) => t.value));
         const isBuilder = isTeamProject(projectPath);
@@ -183,6 +303,7 @@ function registerInit(program) {
             console.log(JSON.stringify({
                 status: 'ok',
                 mode: isBuilder ? 'builder' : 'user',
+                migrated,
                 global: {
                     status: globalStatus,
                     path: (0, command_adapter_js_1.getGlobalCommandDir)(),

package/dist/commands/publish.d.ts

@@ -2,21 +2,46 @@ import { Command } from 'commander';
 export interface RequiresCli {
     name: string;
     install?: string;
+    required?: boolean;
 }
 export interface RequiresMcp {
     name: string;
     package?: string;
+    required?: boolean;
+    config?: {
+        command: string;
+        args?: string[];
+    };
+    env?: string[];
+}
+export interface RequiresConnector {
+    name: string;
+    type: string;
+    auth?: string;
+    env?: string;
+    required?: boolean;
+    description?: string;
 }
 export interface RequiresEnv {
     name: string;
-    optional?: boolean;
+    required?: boolean;
     description?: string;
 }
+export interface RequiresNpm {
+    name: string;
+    required?: boolean;
+}
 export interface Requires {
     cli?: RequiresCli[];
     mcp?: RequiresMcp[];
-    npm?: string[];
+    npm?: (string | RequiresNpm)[];
     env?: RequiresEnv[];
     teams?: string[];
+    connectors?: RequiresConnector[];
+    runtime?: {
+        node?: string;
+        python?: string;
+    };
+    permissions?: string[];
 }
 export declare function registerPublish(program: Command): void;

package/dist/commands/publish.js

@@ -12,6 +12,10 @@ const tar_1 = require("tar");
 const config_js_1 = require("../lib/config.js");
 const VALID_DIRS = ['skills', 'agents', 'rules', 'commands'];
 const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.webp'];
+/** 개별 포트폴리오 이미지 최대 크기 (2 MB) */
+const MAX_IMAGE_SIZE = 2 * 1024 * 1024;
+/** 전체 업로드 최대 크기 (10 MB) */
+const MAX_TOTAL_UPLOAD_SIZE = 10 * 1024 * 1024;
 function parseRelayYaml(content) {
     const raw = js_yaml_1.default.load(content) ?? {};
     const tags = Array.isArray(raw.tags)
@@ -93,15 +97,15 @@ function collectPortfolio(teamDir, yamlPortfolio) {
             return fs_1.default.existsSync(absPath);
         });
     }
-    // Auto-scan ./portfolio/
-    const portfolioDir = path_1.default.join(teamDir, 'portfolio');
+    // Auto-scan .relay/portfolio/
+    const portfolioDir = path_1.default.join(teamDir, '.relay', 'portfolio');
     if (!fs_1.default.existsSync(portfolioDir))
         return [];
     const files = fs_1.default.readdirSync(portfolioDir)
         .filter((f) => IMAGE_EXTS.some((ext) => f.toLowerCase().endsWith(ext)))
         .sort();
     return files.map((f) => ({
-        path: path_1.default.join('portfolio', f),
+        path: path_1.default.join('.relay', 'portfolio', f),
         title: path_1.default.basename(f, path_1.default.extname(f)).replace(/[-_]/g, ' '),
     }));
 }
@@ -140,13 +144,23 @@ async function publishToApi(token, tarPath, metadata, teamDir, portfolioEntries)
     const form = new FormData();
     form.append('package', blob, `${metadata.slug}-${metadata.version}.tar.gz`);
     form.append('metadata', JSON.stringify(metadata));
-    // Attach portfolio images
+    // Attach portfolio images (with size validation)
     if (portfolioEntries.length > 0) {
         const portfolioMeta = [];
+        let totalImageSize = 0;
         for (let i = 0; i < portfolioEntries.length; i++) {
             const entry = portfolioEntries[i];
             const absPath = path_1.default.resolve(teamDir, entry.path);
             const imgBuffer = fs_1.default.readFileSync(absPath);
+            if (imgBuffer.length > MAX_IMAGE_SIZE) {
+                const sizeMB = (imgBuffer.length / 1024 / 1024).toFixed(1);
+                throw new Error(`포트폴리오 이미지 '${path_1.default.basename(entry.path)}'이(가) 너무 큽니다 (${sizeMB}MB). 최대 ${MAX_IMAGE_SIZE / 1024 / 1024}MB까지 허용됩니다.`);
+            }
+            totalImageSize += imgBuffer.length;
+            if (totalImageSize > MAX_TOTAL_UPLOAD_SIZE) {
+                const totalMB = (totalImageSize / 1024 / 1024).toFixed(1);
+                throw new Error(`포트폴리오 이미지 총 크기가 너무 큽니다 (${totalMB}MB). 최대 ${MAX_TOTAL_UPLOAD_SIZE / 1024 / 1024}MB까지 허용됩니다.`);
+            }
             const ext = path_1.default.extname(entry.path).slice(1) || 'png';
             const mimeType = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : ext === 'webp' ? 'image/webp' : 'image/png';
             const imgBlob = new Blob([imgBuffer], { type: mimeType });
@@ -163,6 +177,7 @@ async function publishToApi(token, tarPath, metadata, teamDir, portfolioEntries)
         method: 'POST',
         headers: { Authorization: `Bearer ${token}` },
         body: form,
+        redirect: 'error',
     });
     const body = await res.json();
     if (!res.ok) {
@@ -179,14 +194,15 @@ function registerPublish(program) {
         .action(async (opts) => {
         const json = program.opts().json ?? false;
         const teamDir = process.cwd();
-        const relayYamlPath = path_1.default.join(teamDir, 'relay.yaml');
+        const relayDir = path_1.default.join(teamDir, '.relay');
+        const relayYamlPath = path_1.default.join(relayDir, 'relay.yaml');
         const isTTY = Boolean(process.stdin.isTTY) && !json;
-        // Check relay.yaml exists
+        // Check .relay/relay.yaml exists
         if (!fs_1.default.existsSync(relayYamlPath)) {
             if (!isTTY) {
                 console.error(JSON.stringify({
                     error: 'NOT_INITIALIZED',
-                    message: 'relay.yaml이 없습니다. 먼저 `relay init`을 실행하세요.',
+                    message: '.relay/relay.yaml이 없습니다. 먼저 `relay create`를 실행하세요.',
                 }));
                 process.exit(1);
             }
@@ -195,7 +211,7 @@ function registerPublish(program) {
             const dirName = path_1.default.basename(teamDir);
             const defaultSlug = dirName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
             console.error('\n\x1b[36m릴레이 팀 패키지를 초기화합니다.\x1b[0m');
-            console.error('relay.yaml을 생성하기 위해 몇 가지 정보를 입력해주세요.\n');
+            console.error('.relay/relay.yaml을 생성하기 위해 몇 가지 정보를 입력해주세요.\n');
             const name = await promptInput({
                 message: '팀 이름:',
                 default: dirName,
@@ -220,9 +236,9 @@ function registerPublish(program) {
                     { name: '초대 코드 필요', value: 'invite-only' },
                 ],
             });
-            console.error('\n\x1b[2m💡 프로필에 연락처를 설정하면 설치 시 명함이 전달됩니다: relayax.com/dashboard/edit\x1b[0m');
+            console.error('\n\x1b[2m💡 프로필에 연락처를 설정하면 설치 시 명함이 전달됩니다: www.relayax.com/dashboard/edit\x1b[0m');
             if (visibility === 'invite-only') {
-                console.error('\x1b[2m💡 invite-only 팀은 `relay invite <slug> add @username`으로 사용자를 초대하세요.\x1b[0m');
+                console.error('\x1b[2m💡 invite-only 팀은 웹 대시보드에서 사용자를 초대하세요: www.relayax.com/dashboard\x1b[0m');
             }
             console.error('');
             const tags = tagsRaw
@@ -237,8 +253,9 @@ function registerPublish(program) {
                 tags,
                 visibility,
             };
+            fs_1.default.mkdirSync(relayDir, { recursive: true });
             fs_1.default.writeFileSync(relayYamlPath, js_yaml_1.default.dump(yamlData, { lineWidth: 120 }), 'utf-8');
-            console.error(`\n\x1b[32m✓ relay.yaml이 생성되었습니다.\x1b[0m\n`);
+            console.error(`\n\x1b[32m✓ .relay/relay.yaml이 생성되었습니다.\x1b[0m\n`);
         }
         // Parse relay.yaml
         const yamlContent = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
@@ -252,11 +269,11 @@ function registerPublish(program) {
         }
         // Profile hint
         if (isTTY) {
-            console.error('💡 프로필에 연락처를 설정하면 설치 시 명함이 전달됩니다: relayax.com/dashboard/edit');
+            console.error('💡 프로필에 연락처를 설정하면 설치 시 명함이 전달됩니다: www.relayax.com/dashboard/edit');
         }
-        // Validate structure
+        // Validate structure (콘텐츠는 .relay/ 안에 있음)
         const hasDirs = VALID_DIRS.some((d) => {
-            const dirPath = path_1.default.join(teamDir, d);
+            const dirPath = path_1.default.join(relayDir, d);
             if (!fs_1.default.existsSync(dirPath))
                 return false;
             return fs_1.default.readdirSync(dirPath).filter((f) => !f.startsWith('.')).length > 0;
@@ -264,7 +281,7 @@ function registerPublish(program) {
         if (!hasDirs) {
             console.error(JSON.stringify({
                 error: 'EMPTY_PACKAGE',
-                message: 'skills/, agents/, rules/, commands/ 중 하나 이상에 파일이 있어야 합니다.',
+                message: '.relay/ 안에 skills/, agents/, rules/, commands/ 중 하나 이상에 파일이 있어야 합니다.',
             }));
             process.exit(1);
         }
@@ -277,15 +294,15 @@ function registerPublish(program) {
             }));
             process.exit(1);
         }
-        const detectedCommands = detectCommands(teamDir);
+        const detectedCommands = detectCommands(relayDir);
         const components = {
-            agents: countDir(teamDir, 'agents'),
-            rules: countDir(teamDir, 'rules'),
-            skills: countDir(teamDir, 'skills'),
+            agents: countDir(relayDir, 'agents'),
+            rules: countDir(relayDir, 'rules'),
+            skills: countDir(relayDir, 'skills'),
         };
         // Collect portfolio and long_description
-        const portfolioEntries = collectPortfolio(teamDir, config.portfolio);
-        const longDescription = resolveLongDescription(teamDir, config.long_description);
+        const portfolioEntries = collectPortfolio(relayDir, config.portfolio);
+        const longDescription = resolveLongDescription(relayDir, config.long_description);
         const metadata = {
             slug: config.slug,
             name: config.name,
@@ -307,11 +324,11 @@ function registerPublish(program) {
         }
         let tarPath = null;
         try {
-            tarPath = await createTarball(teamDir);
+            tarPath = await createTarball(relayDir);
             if (!json) {
                 console.error(`업로드 중...`);
             }
-            const result = await publishToApi(token, tarPath, metadata, teamDir, portfolioEntries);
+            const result = await publishToApi(token, tarPath, metadata, relayDir, portfolioEntries);
             if (json) {
                 console.log(JSON.stringify(result));
             }

package/dist/commands/status.js

@@ -48,7 +48,7 @@ function registerStatus(program) {
             hasLocal = command_adapter_js_1.BUILDER_COMMANDS.some((cmd) => fs_1.default.existsSync(path_1.default.join(localDir, `${cmd.id}.md`)));
         }
         // 3. 팀 정보
-        const relayYamlPath = path_1.default.join(projectPath, 'relay.yaml');
+        const relayYamlPath = path_1.default.join(projectPath, '.relay', 'relay.yaml');
         let team = null;
         if (fs_1.default.existsSync(relayYamlPath)) {
             try {

package/dist/lib/command-adapter.js

@@ -88,7 +88,7 @@ exports.USER_COMMANDS = [
 - 설치 결과를 확인합니다 (설치된 파일 수, 사용 가능한 커맨드 목록).
 
 ### 2. 의존성 확인 및 설치
-설치된 팀의 relay.yaml에 \`requires\` 섹션이 있으면 각 항목을 확인하고 처리합니다:
+설치된 팀의 .relay/relay.yaml에 \`requires\` 섹션이 있으면 각 항목을 확인하고 처리합니다:
 
 - **cli**: \`which <name>\`으로 확인 → 없으면 install 명령 실행 또는 안내
 - **npm**: \`npm list <package>\`로 확인 → 없으면 \`npm install\`
@@ -193,7 +193,7 @@ exports.BUILDER_COMMANDS = [
     {
         id: 'relay-publish',
         description: '현재 팀 패키지를 포트폴리오와 함께 relay 마켓플레이스에 배포합니다',
-        body: `현재 디렉토리의 에이전트 팀을 분석하고, 포트폴리오를 생성한 뒤, relay 마켓플레이스에 배포합니다.
+        body: `현재 디렉토리의 에이전트 팀(.relay/)을 분석하고, 보안 점검 및 requirements를 구성한 뒤, 포트폴리오를 생성하고 relay 마켓플레이스에 배포합니다.
 
 ## 실행 단계
 
@@ -204,52 +204,124 @@ exports.BUILDER_COMMANDS = [
 ${LOGIN_JIT_GUIDE}
 
 ### 2. 팀 구조 분석
-- skills/, agents/, rules/, commands/ 디렉토리를 탐색합니다.
+- .relay/ 디렉토리의 skills/, agents/, rules/, commands/를 탐색합니다.
 - 각 파일의 이름과 description을 추출합니다.
-- relay.yaml이 있으면 읽고, 없으면 사용자에게 팀 정보(name, slug, description, tags)를 물어보고 생성합니다.
-
-### 3. 포트폴리오 생성
+- .relay/relay.yaml이 있으면 읽고, 없으면 사용자에게 팀 정보(name, slug, description, tags)를 물어보고 생성합니다.
+
+### 3. 보안 점검 & Requirements 구성 (HITL)
+
+.relay/ 내 모든 파일을 읽고 아래 항목을 분석합니다.
+
+#### 3-1. 시크릿 스캔
+- 하드코딩된 API 키, 토큰, 비밀번호, Private Key 등을 탐색합니다.
+  - 예: sk-..., ghp_..., AKIA..., Bearer 토큰, JWT, -----BEGIN PRIVATE KEY----- 등
+- 발견 시 **즉시 사용자에게 경고**하고, 환경변수로 대체하도록 안내합니다.
+- 시크릿이 제거되지 않으면 배포를 진행하지 않습니다.
+
+#### 3-2. 환경변수 감지
+- 파일 내 환경변수 참조를 감지합니다 (process.env.*, \${VAR}, os.environ 등).
+- 각 환경변수에 대해 사용자에게 확인합니다:
+  - "이 환경변수가 필수인가요, 선택인가요?"
+  - 설명을 추가할 수 있습니다.
+
+#### 3-3. 의존성 감지
+아래 카테고리별로 분석하고, 사용자에게 필수/선택 여부를 확인합니다:
+
+- **cli**: 파일에서 참조하는 CLI 도구 (playwright, ffmpeg, sharp 등)
+- **npm**: import/require되는 npm 패키지
+- **mcp**: MCP 서버 설정이 필요한 경우 (name, package, config, 필요한 env)
+- **connectors**: 외부 서비스 연결 (Notion API, Slack webhook, Supabase 등 — type, auth 방식, 필요한 env)
+- **runtime**: Node.js/Python 등 최소 버전 요구
+- **permissions**: 필요한 에이전트 권한 (filesystem, network, shell)
+- **teams**: 의존하는 다른 relay 팀
+
+각 항목에 대해:
+- \`required: true/false\` — 없으면 팀이 동작하지 않는지, 부분 동작인지
+- \`description\` — 왜 필요한지 짧은 설명
+
+#### 3-4. .relay/relay.yaml에 requires 반영
+분석 결과를 .relay/relay.yaml의 requires 섹션에 저장합니다.
+
+\`\`\`yaml
+# .relay/relay.yaml requires 구조
+requires:
+  env:
+    - name: OPENAI_API_KEY
+      required: true
+      description: "LLM API 호출에 필요"
+    - name: SLACK_WEBHOOK_URL
+      required: false
+      description: "알림 전송 (선택)"
+  cli:
+    - name: playwright
+      install: "npx playwright install"
+      required: true
+  npm:
+    - name: sharp
+      required: true
+  mcp:
+    - name: supabase
+      package: "@supabase/mcp-server"
+      required: false
+      config:
+        command: "npx"
+        args: ["-y", "@supabase/mcp-server"]
+      env: [SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY]
+  connectors:
+    - name: notion
+      type: api
+      auth: bearer_token
+      env: NOTION_API_KEY
+      required: false
+      description: "Notion 페이지 읽기/쓰기"
+  runtime:
+    node: ">=18"
+  permissions:
+    - filesystem
+    - network
+  teams:
+    - contents-team
+\`\`\`
+
+### 4. 포트폴리오 생성
 
 #### Layer 1: 팀 구성 시각화 (자동)
-- 분석된 팀 구조를 HTML로 생성합니다. 내용:
-  - 팀 이름, 버전
-  - Skills 목록 (이름 + 설명)
-  - Commands 목록 (이름 + 설명)
-  - Agents 목록
-  - Rules 목록
-  - 비시각적 팀의 경우 기술 스택이나 데이터 종류 등 추가 정보
-- 생성된 HTML을 Playwright로 스크린샷 캡처합니다. (gstack 또는 webapp-testing 스킬 활용)
-- 결과 PNG를 ./portfolio/team-overview.png에 저장합니다.
+- 분석된 팀 구조를 HTML로 생성합니다.
+- 생성된 HTML을 Playwright로 스크린샷 캡처합니다.
+- 결과 PNG를 ./.relay/portfolio/team-overview.png에 저장합니다.
 
 #### Layer 2: 결과물 쇼케이스 (선택)
-- output/, results/, examples/, portfolio/ 디렉토리를 스캔합니다.
-- 발견된 결과물(PNG, JPG, HTML, PDF)을 사용자에게 보여줍니다.
-- HTML 파일은 Playwright 스크린샷으로 변환합니다.
-- 사용자가 포트폴리오에 포함할 항목을 선택합니다.
-- 선택된 이미지를 ./portfolio/에 저장합니다.
+- output/, results/, examples/ 디렉토리를 스캔합니다.
+- 발견된 결과물을 사용자에게 보여주고 포트폴리오 포함 여부를 선택합니다.
+- 선택된 이미지를 ./.relay/portfolio/에 저장합니다.
+- 각 이미지는 2MB 이하여야 합니다.
 
-### 4. 메타데이터 생성
+### 5. 메타데이터 생성
 - description: skills 내용 기반으로 자동 생성합니다.
 - long_description: 팀 소개 마크다운을 자동 생성합니다 (README.md가 있으면 활용).
 - tags: 팀 특성에 맞는 태그를 추천합니다.
 - 사용자에게 확인: "이대로 배포할까요?"
 
-### 5. relay.yaml 업데이트
-- 생성/수정된 메타데이터와 포트폴리오 경로를 relay.yaml에 반영합니다.
+### 6. .relay/relay.yaml 업데이트
+- 생성/수정된 메타데이터, requires, 포트폴리오 경로를 .relay/relay.yaml에 반영합니다.
 
-### 6. 배포
+### 7. 배포
 - \`relay publish\` 명령어를 실행합니다.
 - 배포 결과와 마켓플레이스 URL을 보여줍니다.
 
 ## 예시
 
 사용자: /relay-publish
-→ 팀 구조 분석: skills 3개, commands 5개, agents 2개
-→ Layer 1: 팀 구성 시각화 HTML 생성 → 스크린샷 캡처
-→ Layer 2: output/ 스캔 → "카드뉴스 예시.png, PDF 보고서.png 발견. 포트폴리오에 포함할까요?"
-→ 사용자 확인 후 relay.yaml 업데이트
+→ 팀 구조 분석: skills 3개, commands 5개
+→ 보안 스캔: ✓ 시크릿 없음
+→ 환경변수 감지: OPENAI_API_KEY, DATABASE_URL
+→ "OPENAI_API_KEY — 필수인가요?" → Yes
+→ "DATABASE_URL — 필수인가요?" → No, 선택
+→ npm 의존성 감지: sharp (필수)
+→ requires 업데이트 완료
+→ 포트폴리오 생성 → 사용자 확인
 → relay publish 실행
-→ "배포 완료! URL: https://relayax.com/teams/contents-team"`,
+→ "배포 완료! URL: https://relayax.com/teams/my-team"`,
     },
 ];
 /** 하위 호환 — 기존 코드에서 RELAY_COMMANDS를 참조하는 경우 */

package/dist/lib/config.d.ts

@@ -1,5 +1,5 @@
 import type { InstalledRegistry } from '../types.js';
-export declare const API_URL = "https://relayax.com";
+export declare const API_URL = "https://www.relayax.com";
 /**
  * 설치 경로를 결정한다.
  * 1. --path 옵션이 있으면 그대로 사용

package/dist/lib/config.js

@@ -14,7 +14,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const ai_tools_js_1 = require("./ai-tools.js");
-exports.API_URL = 'https://relayax.com';
+exports.API_URL = 'https://www.relayax.com';
 const RELAY_DIR = path_1.default.join(os_1.default.homedir(), '.relay');
 const INSTALLED_FILE = path_1.default.join(RELAY_DIR, 'installed.json');
 /**

package/dist/lib/config.js.bak

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_URL = void 0;
+exports.getInstallPath = getInstallPath;
+exports.ensureRelayDir = ensureRelayDir;
+exports.loadToken = loadToken;
+exports.saveToken = saveToken;
+exports.loadInstalled = loadInstalled;
+exports.saveInstalled = saveInstalled;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const ai_tools_js_1 = require("./ai-tools.js");
+exports.API_URL = 'https://relayax.com';
+const RELAY_DIR = path_1.default.join(os_1.default.homedir(), '.relay');
+const INSTALLED_FILE = path_1.default.join(RELAY_DIR, 'installed.json');
+/**
+ * 설치 경로를 결정한다.
+ * 1. --path 옵션이 있으면 그대로 사용
+ * 2. 에이전트 CLI 자동 감지 → 감지된 경로 사용
+ * 3. 감지 안 되면 현재 디렉토리에 직접 설치
+ */
+function getInstallPath(override) {
+    if (override) {
+        const resolved = override.startsWith('~')
+            ? path_1.default.join(os_1.default.homedir(), override.slice(1))
+            : path_1.default.resolve(override);
+        return resolved;
+    }
+    const cwd = process.cwd();
+    const detected = (0, ai_tools_js_1.detectAgentCLIs)(cwd);
+    if (detected.length >= 1) {
+        return path_1.default.join(cwd, detected[0].skillsDir);
+    }
+    return cwd;
+}
+function ensureRelayDir() {
+    if (!fs_1.default.existsSync(RELAY_DIR)) {
+        fs_1.default.mkdirSync(RELAY_DIR, { recursive: true });
+    }
+}
+function loadToken() {
+    const tokenFile = path_1.default.join(RELAY_DIR, 'token');
+    if (!fs_1.default.existsSync(tokenFile))
+        return undefined;
+    try {
+        return fs_1.default.readFileSync(tokenFile, 'utf-8').trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function saveToken(token) {
+    ensureRelayDir();
+    fs_1.default.writeFileSync(path_1.default.join(RELAY_DIR, 'token'), token);
+}
+function loadInstalled() {
+    if (!fs_1.default.existsSync(INSTALLED_FILE)) {
+        return {};
+    }
+    try {
+        const raw = fs_1.default.readFileSync(INSTALLED_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveInstalled(registry) {
+    ensureRelayDir();
+    fs_1.default.writeFileSync(INSTALLED_FILE, JSON.stringify(registry, null, 2));
+}

package/dist/lib/security-scan.d.ts

@@ -0,0 +1,19 @@
+export interface SecretFinding {
+    file: string;
+    line: number;
+    label: string;
+    snippet: string;
+}
+export interface EnvRequirement {
+    name: string;
+    optional: boolean;
+    description: string;
+}
+export interface ScanResult {
+    secrets: SecretFinding[];
+    envRequirements: EnvRequirement[];
+}
+/**
+ * .relay/ 디렉토리 내 모든 텍스트 파일을 스캔한다.
+ */
+export declare function scanForSecrets(relayDir: string): ScanResult;

package/dist/lib/security-scan.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanForSecrets = scanForSecrets;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** 시크릿으로 의심되는 하드코딩 값 패턴 */
+const SECRET_VALUE_PATTERNS = [
+    { pattern: /sk-[a-zA-Z0-9_-]{20,}/, label: 'OpenAI API Key' },
+    { pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/, label: 'Anthropic API Key' },
+    { pattern: /xoxb-[0-9]+-[a-zA-Z0-9]+/, label: 'Slack Bot Token' },
+    { pattern: /xoxp-[0-9]+-[a-zA-Z0-9]+/, label: 'Slack User Token' },
+    { pattern: /ghp_[a-zA-Z0-9]{36,}/, label: 'GitHub Personal Access Token' },
+    { pattern: /gho_[a-zA-Z0-9]{36,}/, label: 'GitHub OAuth Token' },
+    { pattern: /glpat-[a-zA-Z0-9\-_]{20,}/, label: 'GitLab Personal Access Token' },
+    { pattern: /AKIA[0-9A-Z]{16}/, label: 'AWS Access Key ID' },
+    { pattern: /eyJ[a-zA-Z0-9_-]{50,}\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/, label: 'JWT Token' },
+    { pattern: /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/, label: 'Private Key' },
+    { pattern: /AIza[a-zA-Z0-9_-]{35}/, label: 'Google API Key' },
+    { pattern: /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/, label: 'SendGrid API Key' },
+    { pattern: /pk_live_[a-zA-Z0-9]{24,}/, label: 'Stripe Publishable Key' },
+    { pattern: /sk_live_[a-zA-Z0-9]{24,}/, label: 'Stripe Secret Key' },
+    { pattern: /sq0atp-[a-zA-Z0-9_-]{22}/, label: 'Square Access Token' },
+];
+/** 환경변수 참조 패턴 */
+const ENV_REF_PATTERNS = [
+    // process.env.VAR_NAME or process.env['VAR_NAME']
+    /process\.env\.([A-Z][A-Z0-9_]+)/g,
+    /process\.env\[['"]([A-Z][A-Z0-9_]+)['"]\]/g,
+    // $VAR_NAME or ${VAR_NAME} in shell/template contexts
+    /\$\{([A-Z][A-Z0-9_]+)\}/g,
+    /\$([A-Z][A-Z0-9_]{2,})/g,
+    // os.environ['VAR'] or os.environ.get('VAR') (Python)
+    /os\.environ(?:\.get)?\(?['"]([A-Z][A-Z0-9_]+)['"]/g,
+    // ENV['VAR'] or ENV.fetch('VAR') (Ruby)
+    /ENV(?:\.fetch)?\(?['"]([A-Z][A-Z0-9_]+)['"]/g,
+];
+/** 시크릿성 환경변수 이름 키워드 */
+const SECRET_ENV_KEYWORDS = [
+    'KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'CREDENTIAL', 'AUTH',
+    'API_KEY', 'ACCESS_KEY', 'PRIVATE', 'SIGNING',
+];
+function isSecretEnvName(name) {
+    const upper = name.toUpperCase();
+    return SECRET_ENV_KEYWORDS.some((kw) => upper.includes(kw));
+}
+/**
+ * .relay/ 디렉토리 내 모든 텍스트 파일을 스캔한다.
+ */
+function scanForSecrets(relayDir) {
+    const secrets = [];
+    const envNames = new Set();
+    const textExts = ['.md', '.txt', '.yaml', '.yml', '.json', '.ts', '.js', '.py', '.sh', '.rb', '.toml'];
+    function walkDir(dir) {
+        if (!fs_1.default.existsSync(dir))
+            return;
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                walkDir(fullPath);
+            }
+            else {
+                const ext = path_1.default.extname(entry.name).toLowerCase();
+                if (!textExts.includes(ext))
+                    continue;
+                scanFile(fullPath, relayDir);
+            }
+        }
+    }
+    function scanFile(filePath, baseDir) {
+        let content;
+        try {
+            content = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const relPath = path_1.default.relative(baseDir, filePath);
+        const lines = content.split('\n');
+        // 1. 하드코딩된 시크릿 검사
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const { pattern, label } of SECRET_VALUE_PATTERNS) {
+                if (pattern.test(line)) {
+                    const snippet = line.trim().length > 80 ? line.trim().slice(0, 77) + '...' : line.trim();
+                    secrets.push({ file: relPath, line: i + 1, label, snippet });
+                }
+            }
+        }
+        // 2. 환경변수 참조 감지
+        for (const pattern of ENV_REF_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                if (match[1])
+                    envNames.add(match[1]);
+            }
+        }
+    }
+    walkDir(relayDir);
+    // 환경변수를 requirements로 변환
+    const envRequirements = [...envNames]
+        .sort()
+        .map((name) => ({
+        name,
+        optional: !isSecretEnvName(name),
+        description: isSecretEnvName(name) ? `${name} (필수 — 시크릿)` : name,
+    }));
+    return { secrets, envRequirements };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayax-cli",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "description": "RelayAX Agent Team Marketplace CLI - Install and manage agent teams",
   "main": "dist/index.js",
   "bin": {
@@ -35,6 +35,7 @@
   "dependencies": {
     "@inquirer/prompts": "^8.3.2",
     "commander": "^13.1.0",
+    "form-data": "^4.0.5",
     "js-yaml": "^4.1.1",
     "tar": "^7.4.0"
   },