relayax-cli 0.1.94 → 0.1.96

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 커맨드가 없으면 설치한다.
  */
@@ -82,7 +82,7 @@ function registerCreate(program) {
         };
         fs_1.default.writeFileSync(relayYamlPath, js_yaml_1.default.dump(yamlData, { lineWidth: 120 }), 'utf-8');
         // 4. 디렉토리 구조 생성
-        const createdDirs = ['.relay'];
+        const createdDirs = [];
         for (const dir of DEFAULT_DIRS) {
             const dirPath = path_1.default.join(projectPath, dir);
             if (!fs_1.default.existsSync(dirPath)) {

package/dist/commands/init.js

@@ -77,93 +77,22 @@ function hasGlobalUserCommands() {
     return command_adapter_js_1.USER_COMMANDS.every((cmd) => fs_1.default.existsSync((0, command_adapter_js_1.getGlobalCommandPath)(cmd.id)));
 }
 /**
- * 팀 프로젝트인지 감지한다 (.relay/relay.yaml 또는 팀 디렉토리 구조).
+ * 팀 프로젝트인지 감지한다 (.relay/ 디렉토리 내 relay.yaml 또는 팀 디렉토리 구조).
  */
 function isTeamProject(projectPath) {
-    if (fs_1.default.existsSync(path_1.default.join(projectPath, '.relay', '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/
- * - 로컬 레거시 슬래시 커맨드 제거 (글로벌로 이동되므로)
- */
-function detectLegacy(projectPath) {
-    const details = [];
-    if (fs_1.default.existsSync(path_1.default.join(projectPath, 'relay.yaml'))) {
-        details.push('relay.yaml → .relay/relay.yaml');
-    }
-    const legacyPortfolio = path_1.default.join(projectPath, 'portfolio');
-    if (fs_1.default.existsSync(legacyPortfolio) && fs_1.default.statSync(legacyPortfolio).isDirectory()) {
-        const hasImages = fs_1.default.readdirSync(legacyPortfolio).some((f) => ['.png', '.jpg', '.jpeg', '.webp'].some((ext) => f.toLowerCase().endsWith(ext)));
-        if (hasImages) {
-            details.push('portfolio/ → .relay/portfolio/');
-        }
-    }
-    // 로컬에 레거시 슬래시 커맨드가 있는지 확인
-    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/${cmdId}.md 제거 (글로벌로 이동)`);
-                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');
-    // 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.mkdirSync(relayDir, { recursive: true });
-        fs_1.default.renameSync(legacyYaml, newYaml);
-        result.relayYaml = true;
-    }
-    // 2. portfolio/ 이동
-    const legacyPortfolio = path_1.default.join(projectPath, 'portfolio');
-    const newPortfolio = path_1.default.join(relayDir, 'portfolio');
-    if (fs_1.default.existsSync(legacyPortfolio) && fs_1.default.statSync(legacyPortfolio).isDirectory() && !fs_1.default.existsSync(newPortfolio)) {
-        fs_1.default.renameSync(legacyPortfolio, newPortfolio);
-        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')
@@ -173,42 +102,6 @@ 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);
@@ -293,7 +186,6 @@ 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

@@ -21,13 +21,34 @@ function parseRelayYaml(content) {
     const tags = Array.isArray(raw.tags)
         ? raw.tags.map((t) => String(t))
         : [];
-    const portfolio = Array.isArray(raw.portfolio)
-        ? raw.portfolio.map((p) => ({
-            path: String(p.path ?? ''),
-            title: String(p.title ?? ''),
-            description: p.description ? String(p.description) : undefined,
-        })).filter((p) => p.path)
-        : [];
+    // Parse portfolio slots structure
+    const rawPortfolio = raw.portfolio;
+    const portfolio = {};
+    if (rawPortfolio && typeof rawPortfolio === 'object' && !Array.isArray(rawPortfolio)) {
+        // New slot-based format: { cover: {...}, demo: {...}, gallery: [...] }
+        if (rawPortfolio.cover && typeof rawPortfolio.cover === 'object') {
+            const c = rawPortfolio.cover;
+            if (c.path)
+                portfolio.cover = { path: String(c.path) };
+        }
+        if (rawPortfolio.demo && typeof rawPortfolio.demo === 'object') {
+            const d = rawPortfolio.demo;
+            portfolio.demo = {
+                type: String(d.type ?? 'gif'),
+                path: d.path ? String(d.path) : undefined,
+                url: d.url ? String(d.url) : undefined,
+            };
+        }
+        if (Array.isArray(rawPortfolio.gallery)) {
+            portfolio.gallery = rawPortfolio.gallery
+                .map((g) => ({
+                path: String(g.path ?? ''),
+                title: String(g.title ?? ''),
+                description: g.description ? String(g.description) : undefined,
+            }))
+                .filter((g) => g.path);
+        }
+    }
     const requires = raw.requires;
     const rawVisibility = String(raw.visibility ?? '');
     const visibility = rawVisibility === 'login-only' ? 'login-only'
@@ -86,28 +107,58 @@ function countDir(teamDir, dirName) {
     return fs_1.default.readdirSync(dirPath).filter((f) => !f.startsWith('.')).length;
 }
 /**
- * 포트폴리오 이미지를 수집한다.
- * 1. relay.yaml에 portfolio 섹션이 있으면 사용
- * 2. 없으면 ./portfolio/ 디렉토리 자동 스캔
+ * 슬롯 기반 포트폴리오를 PortfolioEntry[] 로 평탄화한다.
+ * relay.yaml에 슬롯이 정의되어 있으면 사용, 없으면 portfolio/ 자동 스캔.
  */
-function collectPortfolio(teamDir, yamlPortfolio) {
-    if (yamlPortfolio.length > 0) {
-        return yamlPortfolio.filter((p) => {
-            const absPath = path_1.default.resolve(teamDir, p.path);
-            return fs_1.default.existsSync(absPath);
-        });
+function collectPortfolio(relayDir, slots) {
+    const entries = [];
+    // Cover
+    if (slots.cover?.path) {
+        const absPath = path_1.default.resolve(relayDir, slots.cover.path);
+        if (fs_1.default.existsSync(absPath)) {
+            entries.push({ path: slots.cover.path, title: 'Cover', slot_type: 'cover' });
+        }
     }
-    // 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('.relay', 'portfolio', f),
-        title: path_1.default.basename(f, path_1.default.extname(f)).replace(/[-_]/g, ' '),
-    }));
+    // Demo
+    if (slots.demo) {
+        if (slots.demo.type === 'video_url' && slots.demo.url) {
+            entries.push({ path: '', title: 'Demo', slot_type: 'demo', demo_url: slots.demo.url });
+        }
+        else if (slots.demo.path) {
+            const absPath = path_1.default.resolve(relayDir, slots.demo.path);
+            if (fs_1.default.existsSync(absPath)) {
+                entries.push({ path: slots.demo.path, title: 'Demo', slot_type: 'demo' });
+            }
+        }
+    }
+    // Gallery
+    if (slots.gallery && slots.gallery.length > 0) {
+        for (const g of slots.gallery.slice(0, 5)) {
+            const absPath = path_1.default.resolve(relayDir, g.path);
+            if (fs_1.default.existsSync(absPath)) {
+                entries.push({ path: g.path, title: g.title, description: g.description, slot_type: 'gallery' });
+            }
+        }
+    }
+    // If no slots defined, auto-scan portfolio/ directory
+    if (entries.length === 0) {
+        const portfolioDir = path_1.default.join(relayDir, 'portfolio');
+        if (fs_1.default.existsSync(portfolioDir)) {
+            const files = fs_1.default.readdirSync(portfolioDir)
+                .filter((f) => IMAGE_EXTS.some((ext) => f.toLowerCase().endsWith(ext)))
+                .sort();
+            // First image as cover, rest as gallery
+            for (let i = 0; i < files.length && i < 6; i++) {
+                const f = files[i];
+                entries.push({
+                    path: path_1.default.join('portfolio', f),
+                    title: path_1.default.basename(f, path_1.default.extname(f)).replace(/[-_]/g, ' '),
+                    slot_type: i === 0 ? 'cover' : 'gallery',
+                });
+            }
+        }
+    }
+    return entries;
 }
 /**
  * long_description을 결정한다.
@@ -144,12 +195,24 @@ 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 (with size validation)
+    // Attach portfolio images (with size validation and slot_type)
     if (portfolioEntries.length > 0) {
         const portfolioMeta = [];
         let totalImageSize = 0;
+        let fileIndex = 0;
         for (let i = 0; i < portfolioEntries.length; i++) {
             const entry = portfolioEntries[i];
+            // video_url demo has no file to upload
+            if (entry.slot_type === 'demo' && entry.demo_url && !entry.path) {
+                portfolioMeta.push({
+                    title: entry.title,
+                    description: entry.description,
+                    sort_order: i,
+                    slot_type: entry.slot_type,
+                    demo_url: entry.demo_url,
+                });
+                continue;
+            }
             const absPath = path_1.default.resolve(teamDir, entry.path);
             const imgBuffer = fs_1.default.readFileSync(absPath);
             if (imgBuffer.length > MAX_IMAGE_SIZE) {
@@ -162,13 +225,16 @@ async function publishToApi(token, tarPath, metadata, teamDir, portfolioEntries)
                 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 mimeType = ext === 'gif' ? 'image/gif' : ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : ext === 'webp' ? 'image/webp' : 'image/png';
             const imgBlob = new Blob([imgBuffer], { type: mimeType });
-            form.append(`portfolio[${i}]`, imgBlob, path_1.default.basename(entry.path));
+            form.append(`portfolio[${fileIndex}]`, imgBlob, path_1.default.basename(entry.path));
+            fileIndex++;
             portfolioMeta.push({
                 title: entry.title,
                 description: entry.description,
                 sort_order: i,
+                slot_type: entry.slot_type,
+                demo_url: entry.demo_url,
             });
         }
         form.append('portfolio_meta', JSON.stringify(portfolioMeta));
@@ -177,6 +243,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) {
@@ -235,9 +302,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 팀은 웹 대시보드에서 사용자를 초대하세요: relayax.com/dashboard\x1b[0m');
+                console.error('\x1b[2m💡 invite-only 팀은 웹 대시보드에서 사용자를 초대하세요: www.relayax.com/dashboard\x1b[0m');
             }
             console.error('');
             const tags = tagsRaw
@@ -268,11 +335,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;
@@ -280,7 +347,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);
         }
@@ -293,15 +360,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,
@@ -323,11 +390,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/lib/command-adapter.js

@@ -193,7 +193,7 @@ exports.BUILDER_COMMANDS = [
     {
         id: 'relay-publish',
         description: '현재 팀 패키지를 포트폴리오와 함께 relay 마켓플레이스에 배포합니다',
-        body: `현재 디렉토리의 에이전트 팀을 분석하고, 포트폴리오를 생성한 뒤, relay 마켓플레이스에 배포합니다.
+        body: `현재 디렉토리의 에이전트 팀(.relay/)을 분석하고, 보안 점검 및 requirements를 구성한 뒤, 포트폴리오를 생성하고 relay 마켓플레이스에 배포합니다.
 
 ## 실행 단계
 
@@ -204,52 +204,153 @@ exports.BUILDER_COMMANDS = [
 ${LOGIN_JIT_GUIDE}
 
 ### 2. 팀 구조 분석
-- skills/, agents/, rules/, commands/ 디렉토리를 탐색합니다.
+- .relay/ 디렉토리의 skills/, agents/, rules/, commands/를 탐색합니다.
 - 각 파일의 이름과 description을 추출합니다.
 - .relay/relay.yaml이 있으면 읽고, 없으면 사용자에게 팀 정보(name, slug, description, tags)를 물어보고 생성합니다.
 
-### 3. 포트폴리오 생성
-
-#### Layer 1: 팀 구성 시각화 (자동)
-- 분석된 팀 구조를 HTML로 생성합니다. 내용:
+### 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. 포트폴리오 생성 (슬롯 기반)
+
+포트폴리오는 3가지 슬롯으로 구성됩니다. .relay/portfolio/ 디렉토리에 저장합니다.
+
+#### 슬롯 1: cover (필수 — 마켓 리스팅 카드)
+- 규격: 1200x630px, WebP, 최대 500KB
+- 팀 구조를 요약하는 카드 HTML을 생성합니다:
   - 팀 이름, 버전
   - Skills 목록 (이름 + 설명)
-  - Commands 목록 (이름 + 설명)
-  - Agents 목록
-  - Rules 목록
-  - 비시각적 팀의 경우 기술 스택이나 데이터 종류 등 추가 정보
-- 생성된 HTML을 Playwright로 스크린샷 캡처합니다. (gstack 또는 webapp-testing 스킬 활용)
-- 결과 PNG를 ./.relay/portfolio/team-overview.png에 저장합니다.
-
-#### Layer 2: 결과물 쇼케이스 (선택)
+  - Commands 목록
+  - 주요 기능 요약
+- 생성된 HTML을 Playwright로 1200x630 뷰포트에서 스크린샷 캡처합니다.
+- .relay/portfolio/cover.png에 저장합니다.
+- 사용자에게 "이 cover를 사용할까요?" 확인. 직접 제공도 가능.
+
+#### 슬롯 2: demo (선택 — 동작 시연)
+- 팀 유형에 따라 제안 여부를 판단합니다:
+  - 브라우저 자동화 키워드 감지 (playwright, puppeteer, crawl, scrape, browser) → GIF 데모 제안
+  - 그 외 → 건너뜀 (사용자가 원하면 수동 추가)
+- GIF: 최대 5MB, .relay/portfolio/demo.gif에 저장
+- 또는 외부 영상 URL (YouTube, Loom 등)을 relay.yaml에 기록
+- 사용자에게 "데모를 녹화할까요?" / "영상 URL이 있나요?" 확인
+
+#### 슬롯 3: gallery (선택 — 결과물 쇼케이스, 최대 5장)
+- 규격: 800x600px 이하, WebP, 각 500KB 이하
 - output/, results/, examples/ 디렉토리를 스캔합니다.
-- 발견된 결과물(PNG, JPG, HTML, PDF)을 사용자에게 보여줍니다.
-- HTML 파일은 Playwright 스크린샷으로 변환합니다.
+- 큰 이미지 → 사용자에게 "어느 영역을 보여줄까요?" 확인 후 핵심 영역 crop
+- HTML 파일 → Playwright 스크린샷으로 변환
 - 사용자가 포트폴리오에 포함할 항목을 선택합니다.
-- 선택된 이미지를 ./.relay/portfolio/에 저장합니다.
+- .relay/portfolio/에 저장합니다.
 
-### 4. 메타데이터 생성
+### 5. 메타데이터 생성
 - description: skills 내용 기반으로 자동 생성합니다.
 - long_description: 팀 소개 마크다운을 자동 생성합니다 (README.md가 있으면 활용).
 - tags: 팀 특성에 맞는 태그를 추천합니다.
 - 사용자에게 확인: "이대로 배포할까요?"
 
-### 5. .relay/relay.yaml 업데이트
-- 생성/수정된 메타데이터와 포트폴리오 경로를 .relay/relay.yaml에 반영합니다.
-
-### 6. 배포
+### 6. .relay/relay.yaml 업데이트
+- 메타데이터, requires, 포트폴리오 슬롯을 .relay/relay.yaml에 반영합니다.
+
+\`\`\`yaml
+portfolio:
+  cover:
+    path: portfolio/cover.png
+  demo:                          # 선택
+    type: gif
+    path: portfolio/demo.gif
+  gallery:                       # 선택, 최대 5장
+    - path: portfolio/example-1.png
+      title: "카드뉴스 예시"
+\`\`\`
+
+### 7. 배포
 - \`relay publish\` 명령어를 실행합니다.
 - 배포 결과와 마켓플레이스 URL을 보여줍니다.
 
 ## 예시
 
 사용자: /relay-publish
-→ 팀 구조 분석: skills 3개, commands 5개, agents 2개
-→ Layer 1: 팀 구성 시각화 HTML 생성 → 스크린샷 캡처
-→ Layer 2: output/ 스캔 → "카드뉴스 예시.png, PDF 보고서.png 발견. 포트폴리오에 포함할까요?"
-→ 사용자 확인 후 .relay/relay.yaml 업데이트
+→ 팀 구조 분석: skills 3개, commands 5개
+→ 보안 스캔: ✓ 시크릿 없음
+→ 환경변수 감지: OPENAI_API_KEY (필수), DATABASE_URL (선택)
+→ requires 업데이트 완료
+→ cover 생성: 팀 구조 카드 HTML → 1200x630 스크린샷
+→ demo: "브라우저 자동화 감지. GIF 데모 녹화할까요?" → Yes → 녹화 완료
+→ gallery: output/ 스캔 → "카드뉴스 예시.png 포함?" → Yes → crop + 리사이즈
 → 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/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.94",
+  "version": "0.1.96",
   "description": "RelayAX Agent Team Marketplace CLI - Install and manage agent teams",
   "main": "dist/index.js",
   "bin": {