relayax-cli 0.2.40 → 0.3.41

package/dist/commands/list.js

@@ -2,30 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerList = registerList;
 const config_js_1 = require("../lib/config.js");
-async function fetchSpaceTeamList(spaceSlug, token) {
-    const res = await fetch(`${config_js_1.API_URL}/api/spaces/${spaceSlug}/teams`, {
+async function fetchOrgTeamList(orgSlug, token) {
+    const res = await fetch(`${config_js_1.API_URL}/api/orgs/${orgSlug}/teams`, {
         headers: { Authorization: `Bearer ${token}` },
         signal: AbortSignal.timeout(8000),
     });
     if (!res.ok) {
         const body = await res.text();
-        throw new Error(`Space 팀 목록 조회 실패 (${res.status}): ${body}`);
+        throw new Error(`Org 팀 목록 조회 실패 (${res.status}): ${body}`);
     }
-    const data = (await res.json());
-    if (Array.isArray(data))
-        return data;
-    return data.teams ?? [];
+    return (await res.json());
 }
 function registerList(program) {
     program
         .command('list')
         .description('설치된 에이전트 팀 목록')
-        .option('--space <slug>', 'Space 팀 목록 조회')
+        .option('--org <slug>', 'Organization 팀 목록 조회')
         .action(async (opts) => {
         const json = program.opts().json ?? false;
-        // --space 옵션: Space 팀 목록
-        if (opts.space) {
-            const spaceSlug = opts.space;
+        // --org 옵션: Org 팀 목록
+        if (opts.org) {
+            const orgSlug = opts.org;
             const token = await (0, config_js_1.getValidToken)();
             if (!token) {
                 if (json) {
@@ -38,23 +35,23 @@ function registerList(program) {
                 process.exit(1);
             }
             try {
-                const teams = await fetchSpaceTeamList(spaceSlug, token);
+                const teams = await fetchOrgTeamList(orgSlug, token);
                 if (json) {
-                    console.log(JSON.stringify({ space: spaceSlug, teams }));
+                    console.log(JSON.stringify({ org: orgSlug, teams }));
                     return;
                 }
                 if (teams.length === 0) {
-                    console.log(`\n${spaceSlug} Space에 추가된 팀이 없습니다.`);
+                    console.log(`\n@${orgSlug} Organization에 팀이 없습니다.`);
                     return;
                 }
-                console.log(`\n\x1b[1m${spaceSlug} Space 팀 목록\x1b[0m (${teams.length}개):\n`);
+                console.log(`\n\x1b[1m@${orgSlug} 팀 목록\x1b[0m (${teams.length}개):\n`);
                 for (const t of teams) {
                     const desc = t.description
                         ? `  \x1b[90m${t.description.length > 50 ? t.description.slice(0, 50) + '...' : t.description}\x1b[0m`
                         : '';
-                    console.log(`  \x1b[36m${t.slug}\x1b[0m  \x1b[1m${t.name}\x1b[0m${desc}`);
+                    console.log(`  \x1b[36m@${t.owner}/${t.slug}\x1b[0m  \x1b[1m${t.name}\x1b[0m${desc}`);
                 }
-                console.log(`\n\x1b[33m💡 설치: relay install @spaces/${spaceSlug}/<팀슬러그>\x1b[0m`);
+                console.log(`\n\x1b[33m  설치: relay install @${orgSlug}/<팀슬러그>\x1b[0m`);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -80,7 +77,7 @@ function registerList(program) {
                 installed_at: info.installed_at,
                 scope: 'global',
                 deploy_scope: info.deploy_scope,
-                space_slug: info.space_slug,
+                org_slug: info.org_slug,
             });
             seen.add(slug);
         }
@@ -94,7 +91,7 @@ function registerList(program) {
                 installed_at: info.installed_at,
                 scope: 'local',
                 deploy_scope: info.deploy_scope,
-                space_slug: info.space_slug,
+                org_slug: info.org_slug,
             });
         }
         if (json) {
@@ -113,8 +110,8 @@ function registerList(program) {
                     : item.deploy_scope === 'local'
                         ? '\x1b[33m로컬\x1b[0m'
                         : '\x1b[90m미배치\x1b[0m';
-                const spaceLabel = item.space_slug ? `  \x1b[90m[Space: ${item.space_slug}]\x1b[0m` : '';
-                console.log(`  \x1b[36m${item.slug}\x1b[0m  v${item.version}  ${scopeLabel}  (${date})${spaceLabel}`);
+                const orgLabel = item.org_slug ? `  \x1b[90m[Org: ${item.org_slug}]\x1b[0m` : '';
+                console.log(`  \x1b[36m${item.slug}\x1b[0m  v${item.version}  ${scopeLabel}  (${date})${orgLabel}`);
             }
         }
     });

package/dist/commands/orgs.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+export interface OrgInfo {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    role: string;
+}
+export declare function fetchMyOrgs(token: string): Promise<OrgInfo[]>;
+export declare function registerOrgs(program: Command): void;

package/dist/commands/orgs.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMyOrgs = fetchMyOrgs;
+exports.registerOrgs = registerOrgs;
+const config_js_1 = require("../lib/config.js");
+async function fetchMyOrgs(token) {
+    const res = await fetch(`${config_js_1.API_URL}/api/orgs`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) {
+        throw new Error(`Organization 목록 조회 실패 (${res.status})`);
+    }
+    return (await res.json());
+}
+function registerOrgs(program) {
+    const orgsCmd = program
+        .command('orgs')
+        .description('Organization 관련 명령어');
+    orgsCmd
+        .command('list')
+        .description('내 Organization 목록을 확인합니다')
+        .action(async () => {
+        const json = program.opts().json ?? false;
+        const token = await (0, config_js_1.getValidToken)();
+        if (!token) {
+            if (json) {
+                console.error(JSON.stringify({ error: 'LOGIN_REQUIRED', message: '로그인이 필요합니다.', fix: 'relay login 실행 후 재시도하세요.' }));
+            }
+            else {
+                console.error('\x1b[31m오류: 로그인이 필요합니다.\x1b[0m');
+                console.error('  relay login을 먼저 실행하세요.');
+            }
+            process.exit(1);
+        }
+        try {
+            const orgs = await fetchMyOrgs(token);
+            if (json) {
+                console.log(JSON.stringify({ orgs }));
+                return;
+            }
+            if (orgs.length === 0) {
+                console.log('\nOrganization이 없습니다.');
+                console.log('\x1b[33m  Organization을 만들려면: relay orgs create "이름"\x1b[0m');
+            }
+            else {
+                console.log(`\n\x1b[1m내 Organization\x1b[0m (${orgs.length}개):\n`);
+                for (const o of orgs) {
+                    const role = o.role === 'owner' ? '\x1b[33m오너\x1b[0m'
+                        : o.role === 'admin' ? '\x1b[36m관리자\x1b[0m'
+                            : o.role === 'builder' ? '\x1b[36m빌더\x1b[0m'
+                                : '\x1b[90m멤버\x1b[0m';
+                    const desc = o.description
+                        ? `  \x1b[90m${o.description.length > 40 ? o.description.slice(0, 40) + '...' : o.description}\x1b[0m`
+                        : '';
+                    console.log(`  \x1b[36m@${o.slug}\x1b[0m  \x1b[1m${o.name}\x1b[0m  ${role}${desc}`);
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (json) {
+                console.error(JSON.stringify({ error: 'FETCH_FAILED', message, fix: '네트워크 연결을 확인하거나 잠시 후 재시도하세요.' }));
+            }
+            else {
+                console.error(`\x1b[31m오류: ${message}\x1b[0m`);
+            }
+            process.exit(1);
+        }
+    });
+    orgsCmd
+        .command('create <name>')
+        .description('새 Organization을 생성합니다')
+        .option('--slug <slug>', 'URL slug (미지정 시 이름에서 자동 생성)')
+        .action(async (name, opts) => {
+        const json = program.opts().json ?? false;
+        const token = await (0, config_js_1.getValidToken)();
+        if (!token) {
+            if (json) {
+                console.error(JSON.stringify({ error: 'LOGIN_REQUIRED', message: '로그인이 필요합니다.', fix: 'relay login 실행 후 재시도하세요.' }));
+            }
+            else {
+                console.error('\x1b[31m오류: 로그인이 필요합니다.\x1b[0m');
+            }
+            process.exit(1);
+        }
+        const slug = opts.slug ?? name
+            .toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, '')
+            .replace(/[\s]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 50);
+        try {
+            const res = await fetch(`${config_js_1.API_URL}/api/orgs`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({ name, slug }),
+            });
+            if (!res.ok) {
+                const body = await res.json().catch(() => ({ message: `${res.status}` }));
+                throw new Error(body.message ?? `Organization 생성 실패 (${res.status})`);
+            }
+            const org = await res.json();
+            if (json) {
+                console.log(JSON.stringify({ status: 'created', org }));
+            }
+            else {
+                console.log(`\x1b[32m✅ Organization "${org.name}" (@${org.slug}) 생성 완료\x1b[0m`);
+                console.log(`\n\x1b[33m  팀 배포: relay publish --org ${org.slug}\x1b[0m`);
+                console.log(`\x1b[33m  멤버 초대: www.relayax.com/orgs/${org.slug}/members\x1b[0m`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (json) {
+                console.error(JSON.stringify({ error: 'CREATE_FAILED', message }));
+            }
+            else {
+                console.error(`\x1b[31m오류: ${message}\x1b[0m`);
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/package.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerPackage(program: Command): void;

package/dist/commands/package.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPackage = registerPackage;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const ai_tools_js_1 = require("../lib/ai-tools.js");
+const SYNC_DIRS = ['skills', 'commands', 'agents', 'rules'];
+const EXCLUDE_SUBDIRS = ['relay']; // relay CLI 전용 하위 디렉토리 제외
+// ─── Helpers ───
+function fileHash(filePath) {
+    const content = fs_1.default.readFileSync(filePath);
+    return crypto_1.default.createHash('md5').update(content).digest('hex');
+}
+/**
+ * 디렉토리를 재귀 탐색하여 파일 목록을 반환한다.
+ * baseDir 기준 상대 경로 + 해시.
+ */
+function scanDir(baseDir, subDir) {
+    const fullDir = path_1.default.join(baseDir, subDir);
+    if (!fs_1.default.existsSync(fullDir))
+        return [];
+    const entries = [];
+    function walk(dir) {
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else {
+                const relPath = path_1.default.relative(baseDir, fullPath);
+                entries.push({ relPath, hash: fileHash(fullPath) });
+            }
+        }
+    }
+    walk(fullDir);
+    return entries;
+}
+/**
+ * 소스 디렉토리(예: .claude/)에서 배포 가능한 콘텐츠를 스캔한다.
+ * relay/ 하위 디렉토리는 제외.
+ */
+function scanSource(projectPath, tool) {
+    const sourceBase = path_1.default.join(projectPath, tool.skillsDir);
+    const files = [];
+    const summary = {};
+    for (const dir of SYNC_DIRS) {
+        const fullDir = path_1.default.join(sourceBase, dir);
+        if (!fs_1.default.existsSync(fullDir))
+            continue;
+        // 제외 대상 필터링 (예: commands/relay/)
+        const dirEntries = fs_1.default.readdirSync(fullDir, { withFileTypes: true });
+        let count = 0;
+        for (const entry of dirEntries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.isDirectory() && EXCLUDE_SUBDIRS.includes(entry.name))
+                continue;
+            const entryPath = path_1.default.join(fullDir, entry.name);
+            if (entry.isDirectory()) {
+                // 하위 파일 재귀 탐색
+                const subFiles = scanDir(sourceBase, path_1.default.join(dir, entry.name));
+                // relPath를 sourceBase 기준 → SYNC_DIRS 기준으로 유지
+                files.push(...subFiles);
+                count += subFiles.length > 0 ? 1 : 0; // 디렉토리 단위로 카운트
+            }
+            else {
+                const relPath = path_1.default.relative(sourceBase, entryPath);
+                files.push({ relPath, hash: fileHash(entryPath) });
+                count++;
+            }
+        }
+        if (count > 0)
+            summary[dir] = count;
+    }
+    return { tool, files, summary };
+}
+/**
+ * .relay/ 디렉토리의 현재 콘텐츠를 스캔한다.
+ */
+function scanRelay(relayDir) {
+    const files = [];
+    for (const dir of SYNC_DIRS) {
+        files.push(...scanDir(relayDir, dir));
+    }
+    return files;
+}
+/**
+ * 소스와 .relay/를 비교하여 diff를 생성한다.
+ */
+function computeDiff(sourceFiles, relayFiles) {
+    const relayMap = new Map(relayFiles.map((f) => [f.relPath, f.hash]));
+    const sourceMap = new Map(sourceFiles.map((f) => [f.relPath, f.hash]));
+    const diff = [];
+    // 소스에 있는 파일
+    for (const [relPath, hash] of sourceMap) {
+        const relayHash = relayMap.get(relPath);
+        if (!relayHash) {
+            diff.push({ relPath, status: 'added' });
+        }
+        else if (relayHash !== hash) {
+            diff.push({ relPath, status: 'modified' });
+        }
+        else {
+            diff.push({ relPath, status: 'unchanged' });
+        }
+    }
+    // .relay/에만 있는 파일 (소스에서 삭제됨)
+    for (const [relPath] of relayMap) {
+        if (!sourceMap.has(relPath)) {
+            diff.push({ relPath, status: 'deleted' });
+        }
+    }
+    return diff.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+/**
+ * 소스에서 .relay/로 파일을 동기화한다.
+ */
+function syncToRelay(sourceBase, relayDir, diff) {
+    for (const entry of diff) {
+        const sourcePath = path_1.default.join(sourceBase, entry.relPath);
+        const relayPath = path_1.default.join(relayDir, entry.relPath);
+        if (entry.status === 'added' || entry.status === 'modified') {
+            fs_1.default.mkdirSync(path_1.default.dirname(relayPath), { recursive: true });
+            fs_1.default.copyFileSync(sourcePath, relayPath);
+        }
+        else if (entry.status === 'deleted') {
+            if (fs_1.default.existsSync(relayPath)) {
+                fs_1.default.unlinkSync(relayPath);
+                // 빈 디렉토리 정리
+                const parentDir = path_1.default.dirname(relayPath);
+                try {
+                    const remaining = fs_1.default.readdirSync(parentDir).filter((f) => !f.startsWith('.'));
+                    if (remaining.length === 0)
+                        fs_1.default.rmdirSync(parentDir);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+}
+// ─── Command ───
+function registerPackage(program) {
+    program
+        .command('package')
+        .description('소스 디렉토리에서 .relay/로 콘텐츠를 동기화합니다')
+        .option('--source <dir>', '소스 디렉토리 지정 (예: .claude)')
+        .option('--sync', '변경사항을 .relay/에 즉시 반영', false)
+        .option('--init', '최초 패키징: 소스 감지 → .relay/ 초기화', false)
+        .action(async (opts) => {
+        const json = program.opts().json ?? false;
+        const projectPath = process.cwd();
+        const relayDir = path_1.default.join(projectPath, '.relay');
+        const relayYamlPath = path_1.default.join(relayDir, 'relay.yaml');
+        // ─── 최초 패키징 (--init) ───
+        if (opts.init || !fs_1.default.existsSync(relayYamlPath)) {
+            const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+            // 각 도구의 콘텐츠 스캔
+            const scans = detected
+                .map((tool) => scanSource(projectPath, tool))
+                .filter((s) => s.files.length > 0);
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'init_required',
+                    detected: scans.map((s) => ({
+                        source: s.tool.skillsDir,
+                        name: s.tool.name,
+                        summary: s.summary,
+                        fileCount: s.files.length,
+                    })),
+                }));
+            }
+            else {
+                if (scans.length === 0) {
+                    console.error('배포 가능한 에이전트 콘텐츠를 찾지 못했습니다.');
+                    console.error('skills/, commands/, agents/, rules/ 중 하나를 만들어주세요.');
+                    process.exit(1);
+                }
+                console.error('\n프로젝트에서 발견된 에이전트 콘텐츠:\n');
+                for (const scan of scans) {
+                    const parts = Object.entries(scan.summary)
+                        .map(([dir, count]) => `${dir} ${count}개`)
+                        .join(', ');
+                    console.error(`  📁 ${scan.tool.skillsDir}/ — ${parts}`);
+                }
+                console.error('');
+            }
+            return;
+        }
+        // ─── 재패키징 (source 기반 동기화) ───
+        const yamlContent = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
+        const config = js_yaml_1.default.load(yamlContent);
+        const source = opts.source ?? config.source;
+        if (!source) {
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'no_source',
+                    message: 'relay.yaml에 source 필드가 없습니다. --source 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.',
+                }));
+            }
+            else {
+                console.error('relay.yaml에 source 필드가 없습니다.');
+                console.error('--source <dir> 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.');
+            }
+            process.exit(1);
+        }
+        // 소스 디렉토리 존재 확인
+        const sourceBase = path_1.default.join(projectPath, source);
+        if (!fs_1.default.existsSync(sourceBase)) {
+            const msg = `소스 디렉토리 '${source}'를 찾을 수 없습니다.`;
+            if (json) {
+                console.log(JSON.stringify({ error: 'SOURCE_NOT_FOUND', message: msg }));
+            }
+            else {
+                console.error(msg);
+            }
+            process.exit(1);
+        }
+        // 소스에서 해당 도구 찾기
+        const allTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+        const tool = allTools.find((t) => t.skillsDir === source);
+        const toolName = tool?.name ?? source;
+        // diff 계산
+        const sourceScan = tool
+            ? scanSource(projectPath, tool)
+            : { tool: { name: source, value: source, skillsDir: source }, files: [], summary: {} };
+        // tool이 없으면 직접 스캔
+        if (!tool) {
+            for (const dir of SYNC_DIRS) {
+                const files = scanDir(sourceBase, dir);
+                sourceScan.files.push(...files);
+                if (files.length > 0)
+                    sourceScan.summary[dir] = files.length;
+            }
+        }
+        const relayFiles = scanRelay(relayDir);
+        const diff = computeDiff(sourceScan.files, relayFiles);
+        const summary = {
+            added: diff.filter((d) => d.status === 'added').length,
+            modified: diff.filter((d) => d.status === 'modified').length,
+            deleted: diff.filter((d) => d.status === 'deleted').length,
+            unchanged: diff.filter((d) => d.status === 'unchanged').length,
+        };
+        const hasChanges = summary.added + summary.modified + summary.deleted > 0;
+        // --sync: 즉시 동기화
+        if (opts.sync && hasChanges) {
+            syncToRelay(sourceBase, relayDir, diff);
+        }
+        const result = {
+            source,
+            sourceName: toolName,
+            synced: opts.sync === true && hasChanges,
+            diff: diff.filter((d) => d.status !== 'unchanged'),
+            summary,
+        };
+        if (json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            if (!hasChanges) {
+                console.error(`✓ 소스(${source})와 .relay/가 동기화 상태입니다.`);
+                return;
+            }
+            console.error(`\n📦 소스 동기화 (${source}/ → .relay/)\n`);
+            for (const entry of diff) {
+                if (entry.status === 'unchanged')
+                    continue;
+                const icon = entry.status === 'added' ? '  신규' : entry.status === 'modified' ? '  변경' : '  삭제';
+                console.error(`${icon}: ${entry.relPath}`);
+            }
+            console.error('');
+            console.error(`  합계: 신규 ${summary.added}, 변경 ${summary.modified}, 삭제 ${summary.deleted}, 유지 ${summary.unchanged}`);
+            if (opts.sync) {
+                console.error(`\n✓ .relay/에 반영 완료`);
+            }
+            else {
+                console.error(`\n반영하려면: relay package --sync`);
+            }
+        }
+    });
+}