anpm-io 1.0.0

package/dist/lib/setup-command.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSetupCommand = generateSetupCommand;
+/**
+ * relay.yaml의 requires를 기반으로 setup slash command .md 내용을 생성한다.
+ * requires가 없거나 빈 객체이면 null을 반환한다.
+ */
+function generateSetupCommand(agentName, requires, mainCommandName) {
+    if (!requires)
+        return null;
+    const sections = [];
+    // runtime
+    if (requires.runtime) {
+        const items = [];
+        if (requires.runtime.node)
+            items.push(`- Node.js \`>=${requires.runtime.node}\``);
+        if (requires.runtime.python)
+            items.push(`- Python \`>=${requires.runtime.python}\``);
+        if (items.length > 0) {
+            sections.push(`### 런타임\n${items.join('\n')}`);
+        }
+    }
+    // cli
+    if (requires.cli && requires.cli.length > 0) {
+        const items = requires.cli.map((c) => {
+            const req = c.required !== false ? '필수' : '선택';
+            const install = c.install ? ` — 설치: \`${c.install}\`` : '';
+            return `- \`${c.name}\` (${req})${install}`;
+        });
+        sections.push(`### CLI 도구\n${items.join('\n')}`);
+    }
+    // env
+    if (requires.env && requires.env.length > 0) {
+        const items = requires.env.map((e) => {
+            const req = e.required !== false ? '필수' : '선택';
+            const desc = e.description ? ` — ${e.description}` : '';
+            const hint = e.setup_hint ? `\n  설정 방법:\n${e.setup_hint.split('\n').map((l) => `    ${l}`).join('\n')}` : '';
+            return `- \`${e.name}\` (${req})${desc}${hint}`;
+        });
+        sections.push(`### 환경변수\n${items.join('\n')}`);
+    }
+    // npm
+    if (requires.npm && requires.npm.length > 0) {
+        const items = requires.npm.map((n) => {
+            const name = typeof n === 'string' ? n : n.name;
+            const req = typeof n === 'string' ? '필수' : (n.required !== false ? '필수' : '선택');
+            return `- \`${name}\` (${req})`;
+        });
+        sections.push(`### npm 패키지\n${items.join('\n')}`);
+    }
+    // mcp
+    if (requires.mcp && requires.mcp.length > 0) {
+        const items = requires.mcp.map((m) => {
+            const req = m.required !== false ? '필수' : '선택';
+            const pkg = m.package ? ` — 패키지: \`${m.package}\`` : '';
+            const envList = m.env && m.env.length > 0 ? `\n  필요한 환경변수: ${m.env.map((e) => `\`${e}\``).join(', ')}` : '';
+            const config = m.config ? `\n  설정: \`${JSON.stringify(m.config)}\`` : '';
+            return `- \`${m.name}\` MCP 서버 (${req})${pkg}${envList}${config}`;
+        });
+        sections.push(`### MCP 서버\n${items.join('\n')}`);
+    }
+    if (sections.length === 0)
+        return null;
+    const body = `# ${agentName} 설정 가이드
+
+아래 요구사항을 각각 체크하고, 미충족 항목이 있으면 사용자가 설정할 수 있도록 안내하세요.
+모든 항목이 충족될 때까지 멈추지 말고 끝까지 진행하세요.
+${mainCommandName ? `\n모든 설정이 완료되면 \`/${mainCommandName}\`으로 에이전트를 사용할 수 있다고 안내하세요.` : ''}
+
+${sections.join('\n\n')}`;
+    return `---\ndescription: ${agentName} 설정 가이드 — 필수 요구사항을 확인하고 설정합니다\n---\n\n${body}\n`;
+}

package/dist/lib/slug.d.ts

@@ -0,0 +1,24 @@
+export interface ParsedSlug {
+    owner: string;
+    name: string;
+    full: string;
+}
+/**
+ * 임의의 문자열을 slug로 변환한다.
+ * 한글은 로마자로 변환된다 (예: "콘텐츠 에이전트" → "kontencheu-eijenteu").
+ */
+export declare function slugify(input: string): string;
+/**
+ * Scoped slug(`@owner/name`)를 동기적으로 파싱한다.
+ * 단순 slug는 파싱할 수 없으므로 null을 반환한다.
+ */
+export declare function parseSlug(input: string): ParsedSlug | null;
+/** input이 scoped slug인지 확인 */
+export declare function isScopedSlug(input: string): boolean;
+/** input이 단순 slug인지 확인 */
+export declare function isSimpleSlug(input: string): boolean;
+/**
+ * Scoped 또는 단순 slug를 받아 ParsedSlug를 반환한다.
+ * 단순 slug는 서버에 resolve를 요청한다.
+ */
+export declare function resolveSlug(input: string): Promise<ParsedSlug>;

package/dist/lib/slug.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = slugify;
+exports.parseSlug = parseSlug;
+exports.isScopedSlug = isScopedSlug;
+exports.isSimpleSlug = isSimpleSlug;
+exports.resolveSlug = resolveSlug;
+const api_js_1 = require("./api.js");
+const SCOPED_SLUG_RE = /^@([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)$/;
+const SIMPLE_SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+// ── 한글 로마자 변환 (Revised Romanization) ──
+const INITIALS = [
+    'g', 'kk', 'n', 'd', 'tt', 'r', 'm', 'b', 'pp',
+    's', 'ss', '', 'j', 'jj', 'ch', 'k', 't', 'p', 'h',
+];
+const MEDIALS = [
+    'a', 'ae', 'ya', 'yae', 'eo', 'e', 'yeo', 'ye', 'o',
+    'wa', 'wae', 'oe', 'yo', 'u', 'wo', 'we', 'wi', 'yu',
+    'eu', 'ui', 'i',
+];
+const FINALS = [
+    '', 'k', 'k', 'k', 'n', 'n', 'n', 't', 'l',
+    'l', 'l', 'l', 'l', 'l', 'l', 'l', 'm', 'p',
+    'p', 't', 't', 'ng', 't', 't', 'k', 't', 'p', 't',
+];
+const HANGUL_BASE = 0xAC00;
+function romanize(input) {
+    let result = '';
+    for (const ch of input) {
+        const code = ch.codePointAt(0);
+        if (code >= HANGUL_BASE && code < HANGUL_BASE + 11172) {
+            const offset = code - HANGUL_BASE;
+            const initial = Math.floor(offset / (21 * 28));
+            const medial = Math.floor((offset % (21 * 28)) / 28);
+            const final = offset % 28;
+            result += INITIALS[initial] + MEDIALS[medial] + FINALS[final];
+        }
+        else {
+            result += ch;
+        }
+    }
+    return result;
+}
+/**
+ * 임의의 문자열을 slug로 변환한다.
+ * 한글은 로마자로 변환된다 (예: "콘텐츠 에이전트" → "kontencheu-eijenteu").
+ */
+function slugify(input) {
+    return romanize(input)
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .slice(0, 50);
+}
+/**
+ * Scoped slug(`@owner/name`)를 동기적으로 파싱한다.
+ * 단순 slug는 파싱할 수 없으므로 null을 반환한다.
+ */
+function parseSlug(input) {
+    const m = input.match(SCOPED_SLUG_RE);
+    if (!m)
+        return null;
+    return { owner: m[1], name: m[2], full: input };
+}
+/** input이 scoped slug인지 확인 */
+function isScopedSlug(input) {
+    return SCOPED_SLUG_RE.test(input);
+}
+/** input이 단순 slug인지 확인 */
+function isSimpleSlug(input) {
+    return SIMPLE_SLUG_RE.test(input);
+}
+/**
+ * Scoped 또는 단순 slug를 받아 ParsedSlug를 반환한다.
+ * 단순 slug는 서버에 resolve를 요청한다.
+ */
+async function resolveSlug(input) {
+    // scoped slug면 바로 파싱
+    const parsed = parseSlug(input);
+    if (parsed)
+        return parsed;
+    // 단순 slug인지 검증
+    if (!isSimpleSlug(input)) {
+        throw new Error(`잘못된 slug 형식입니다: '${input}'. @owner/name 또는 name 형태로 입력하세요.`);
+    }
+    // 서버에 resolve 요청
+    const results = await (0, api_js_1.resolveSlugFromServer)(input);
+    if (results.length === 0) {
+        throw new Error(`'${input}' 에이전트를 찾을 수 없습니다.`);
+    }
+    if (results.length === 1) {
+        const r = results[0];
+        return { owner: r.owner, name: r.name, full: r.full };
+    }
+    // 여러 개 매칭
+    const list = results.map((r) => `  ${r.full}`).join('\n');
+    throw new Error(`'${input}'에 해당하는 에이전트가 여러 개입니다. 전체 slug를 지정해주세요:\n${list}`);
+}

package/dist/lib/step-tracker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI 명령 실행을 서버에 기록한다 (fire-and-forget).
+ * device_hash 기준으로 사용자 여정(login → create → publish)을 추적.
+ */
+export declare function trackCommand(command: string, opts?: {
+    slug?: string;
+    success?: boolean;
+}): void;

package/dist/lib/step-tracker.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackCommand = trackCommand;
+const config_js_1 = require("./config.js");
+const device_hash_js_1 = require("./device-hash.js");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+/**
+ * CLI 명령 실행을 서버에 기록한다 (fire-and-forget).
+ * device_hash 기준으로 사용자 여정(login → create → publish)을 추적.
+ */
+function trackCommand(command, opts) {
+    const deviceHash = (0, device_hash_js_1.getDeviceHash)();
+    fetch(`${config_js_1.API_URL}/api/analytics/cli-commands`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            device_hash: deviceHash,
+            command,
+            slug: opts?.slug ?? null,
+            success: opts?.success ?? true,
+            cli_version: pkg.version,
+        }),
+        signal: AbortSignal.timeout(5000),
+    }).catch(() => {
+        // fire-and-forget
+    });
+}

package/dist/lib/storage.d.ts

@@ -0,0 +1,6 @@
+export declare function makeTempDir(): string;
+export declare function removeTempDir(dir: string): void;
+/**
+ * Clone an agent from git URL to destination directory.
+ */
+export declare function clonePackage(gitUrl: string, destDir: string, version?: string): Promise<void>;

package/dist/lib/storage.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTempDir = makeTempDir;
+exports.removeTempDir = removeTempDir;
+exports.clonePackage = clonePackage;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const git_operations_js_1 = require("./git-operations.js");
+function makeTempDir() {
+    return fs_1.default.mkdtempSync(os_1.default.tmpdir() + '/relay-');
+}
+function removeTempDir(dir) {
+    fs_1.default.rmSync(dir, { recursive: true, force: true });
+}
+/**
+ * Clone an agent from git URL to destination directory.
+ */
+async function clonePackage(gitUrl, destDir, version) {
+    await (0, git_operations_js_1.gitInstall)(gitUrl, destDir, version);
+}

package/dist/lib/update-cache.d.ts

@@ -0,0 +1,2 @@
+export declare function isCacheValid(key: 'cli' | string, force?: boolean): boolean;
+export declare function updateCacheTimestamp(key: 'cli' | string): void;

package/dist/lib/update-cache.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCacheValid = isCacheValid;
+exports.updateCacheTimestamp = updateCacheTimestamp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const RELAY_DIR = path_1.default.join(os_1.default.homedir(), '.relay');
+const CACHE_FILE = path_1.default.join(RELAY_DIR, 'last-update-check');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function loadCache() {
+    try {
+        if (!fs_1.default.existsSync(CACHE_FILE))
+            return {};
+        return JSON.parse(fs_1.default.readFileSync(CACHE_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(data) {
+    if (!fs_1.default.existsSync(RELAY_DIR)) {
+        fs_1.default.mkdirSync(RELAY_DIR, { recursive: true });
+    }
+    fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+}
+function isCacheValid(key, force) {
+    if (force)
+        return false;
+    const cache = loadCache();
+    const timestamp = key === 'cli' ? cache.cli : cache.agents?.[key];
+    if (!timestamp)
+        return false;
+    return Date.now() - new Date(timestamp).getTime() < CACHE_TTL_MS;
+}
+function updateCacheTimestamp(key) {
+    const cache = loadCache();
+    const now = new Date().toISOString();
+    if (key === 'cli') {
+        cache.cli = now;
+    }
+    else {
+        if (!cache.agents)
+            cache.agents = {};
+        cache.agents[key] = now;
+    }
+    saveCache(cache);
+}

package/dist/lib/version-check.d.ts

@@ -0,0 +1,10 @@
+export interface UpdateResult {
+    type: 'cli' | 'agent';
+    slug?: string;
+    current: string;
+    latest: string;
+    author?: string;
+}
+export declare function checkCliVersion(force?: boolean): Promise<UpdateResult | null>;
+export declare function checkAgentVersion(slug: string, force?: boolean): Promise<UpdateResult | null>;
+export declare function checkAllAgents(force?: boolean): Promise<UpdateResult[]>;

package/dist/lib/version-check.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCliVersion = checkCliVersion;
+exports.checkAgentVersion = checkAgentVersion;
+exports.checkAllAgents = checkAllAgents;
+const config_js_1 = require("./config.js");
+const api_js_1 = require("./api.js");
+const update_cache_js_1 = require("./update-cache.js");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+async function checkCliVersion(force) {
+    if ((0, update_cache_js_1.isCacheValid)('cli', force))
+        return null;
+    try {
+        const res = await fetch('https://registry.npmjs.org/relayax-cli/latest', {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        (0, update_cache_js_1.updateCacheTimestamp)('cli');
+        if (data.version !== pkg.version) {
+            return { type: 'cli', current: pkg.version, latest: data.version };
+        }
+    }
+    catch {
+        // network error — silently skip
+    }
+    return null;
+}
+async function checkAgentVersion(slug, force) {
+    if ((0, update_cache_js_1.isCacheValid)(slug, force))
+        return null;
+    try {
+        const installed = (0, config_js_1.loadInstalled)();
+        const entry = installed[slug];
+        if (!entry?.version)
+            return null;
+        // system 타입(relay-core)은 CLI 버전 체크로 대체
+        if (entry.type === 'system') {
+            return null;
+        }
+        const agent = await (0, api_js_1.fetchAgentInfo)(slug);
+        (0, update_cache_js_1.updateCacheTimestamp)(slug);
+        // Fire-and-forget usage ping (only when cache expired = actual API call happened)
+        const agentId = entry.agent_id ?? agent.id;
+        if (agentId) {
+            (0, api_js_1.sendUsagePing)(agentId, slug, entry.version);
+        }
+        if (agent.version !== entry.version) {
+            return {
+                type: 'agent',
+                slug,
+                current: entry.version,
+                latest: agent.version,
+                author: agent.author?.username,
+            };
+        }
+    }
+    catch {
+        // network error — silently skip
+    }
+    return null;
+}
+async function checkAllAgents(force) {
+    const installed = (0, config_js_1.loadInstalled)();
+    const slugs = Object.keys(installed);
+    const results = [];
+    for (const slug of slugs) {
+        const result = await checkAgentVersion(slug, force);
+        if (result)
+            results.push(result);
+    }
+    return results;
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+exports.startMcpServer = startMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const config_js_1 = require("../lib/config.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../../package.json');
+// ─── Helpers ───
+function jsonText(obj) {
+    return { type: 'text', text: JSON.stringify(obj) };
+}
+// ─── Server ───
+function createMcpServer() {
+    const server = new mcp_js_1.McpServer({ name: 'relay', version: pkg.version }, { capabilities: { tools: {} } });
+    // ═══ Detail Images — 에이전트 상세페이지 이미지 관리 ═══
+    server.tool('relay_detail_upload', '에이전트 상세페이지 이미지를 업로드합니다. 폴더 내 이미지를 파일명 순으로 정렬하여 업로드합니다 (기존 이미지 전체 교체).', {
+        slug: zod_1.z.string().describe('에이전트 slug'),
+        path: zod_1.z.string().describe('이미지가 있는 폴더 경로 (PNG/GIF/JPEG/WebP)'),
+    }, async ({ slug, path: dirPath }) => {
+        try {
+            const token = await (0, config_js_1.getValidToken)();
+            if (!token)
+                return { content: [jsonText({ error: 'LOGIN_REQUIRED', message: '로그인이 필요합니다.' })], isError: true };
+            const absPath = path_1.default.resolve(dirPath);
+            if (!fs_1.default.existsSync(absPath) || !fs_1.default.statSync(absPath).isDirectory()) {
+                return { content: [jsonText({ error: `폴더를 찾을 수 없습니다: ${absPath}` })], isError: true };
+            }
+            const imageExts = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
+            const files = fs_1.default.readdirSync(absPath)
+                .filter((f) => imageExts.includes(path_1.default.extname(f).toLowerCase()))
+                .sort();
+            if (files.length === 0) {
+                return { content: [jsonText({ error: '폴더에 이미지 파일이 없습니다 (PNG/GIF/JPEG/WebP)' })], isError: true };
+            }
+            const formData = new FormData();
+            for (const file of files) {
+                const filePath = path_1.default.join(absPath, file);
+                const buffer = fs_1.default.readFileSync(filePath);
+                const ext = path_1.default.extname(file).toLowerCase();
+                const mimeMap = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
+                const blob = new Blob([buffer], { type: mimeMap[ext] || 'image/png' });
+                formData.append('files', blob, file);
+            }
+            const res = await fetch(`${config_js_1.API_URL}/api/agents/${slug}/detail-images`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${token}` },
+                body: formData,
+            });
+            if (!res.ok) {
+                const body = await res.json().catch(() => ({}));
+                return { content: [jsonText({ error: body.message || `업로드 실패 (${res.status})` })], isError: true };
+            }
+            const result = await res.json();
+            return { content: [jsonText({ status: 'uploaded', count: result.count, images: result.detail_images })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    server.tool('relay_detail_list', '에이전트 상세페이지 이미지 목록을 조회합니다', {
+        slug: zod_1.z.string().describe('에이전트 slug'),
+    }, async ({ slug }) => {
+        try {
+            const res = await fetch(`${config_js_1.API_URL}/api/agents/${slug}/detail-images`);
+            if (!res.ok) {
+                return { content: [jsonText({ error: `조회 실패 (${res.status})` })], isError: true };
+            }
+            const data = await res.json();
+            return { content: [jsonText({ detail_images: data.detail_images, count: data.detail_images.length })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    server.tool('relay_detail_clear', '에이전트 상세페이지 이미지를 모두 삭제합니다', {
+        slug: zod_1.z.string().describe('에이전트 slug'),
+    }, async ({ slug }) => {
+        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/${slug}/detail-images`, {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!res.ok) {
+                const body = await res.json().catch(() => ({}));
+                return { content: [jsonText({ error: body.message || `삭제 실패 (${res.status})` })], isError: true };
+            }
+            const result = await res.json();
+            return { content: [jsonText({ status: 'cleared', deleted: result.deleted })] };
+        }
+        catch (err) {
+            return { content: [jsonText({ error: String(err) })], isError: true };
+        }
+    });
+    return server;
+}
+// ─── Start ───
+async function startMcpServer() {
+    const server = createMcpServer();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/postinstall.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * postinstall — npm install -g relayax-cli 후 자동 실행
+ *
+ * 1. 감지된 에이전트 CLI에 글로벌 슬래시 커맨드 설치
+ * 2. 설치 결과 안내 메시지 출력
+ */
+export {};

package/dist/postinstall.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * postinstall — npm install -g relayax-cli 후 자동 실행
+ *
+ * 1. 감지된 에이전트 CLI에 글로벌 슬래시 커맨드 설치
+ * 2. 설치 결과 안내 메시지 출력
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_js_1 = require("./commands/init.js");
+const ai_tools_js_1 = require("./lib/ai-tools.js");
+try {
+    const detectedCLIs = (0, ai_tools_js_1.detectGlobalCLIs)();
+    const result = (0, init_js_1.installGlobalUserCommands)();
+    console.log('');
+    console.log('  \x1b[32m✓ anpm 설치 완료!\x1b[0m');
+    console.log('');
+    if (result.tools.length > 0) {
+        console.log(`  \x1b[36m슬래시 커맨드 설치됨:\x1b[0m ${result.tools.join(', ')}`);
+        console.log('');
+        console.log('  사용 가능한 커맨드:');
+        console.log('    /relay-explore     에이전트 탐색 & 추천');
+        console.log('    /relay-create      에이전트 생성 & 배포');
+        console.log('    /relay-status      설치 현황 & Organization');
+        console.log('    /relay-uninstall   에이전트 삭제');
+    }
+    else {
+        console.log('  \x1b[33m에이전트 CLI가 감지되지 않았습니다.\x1b[0m');
+        console.log('  Claude Code, Cursor 등 설치 후 \x1b[36manpm init\x1b[0m을 실행하세요.');
+    }
+    console.log('');
+    console.log('  \x1b[2m시작하기: anpm login\x1b[0m');
+    console.log('');
+}
+catch {
+    // postinstall 실패해도 CLI 설치는 성공해야 함
+    console.log('');
+    console.log('  \x1b[32m✓ anpm 설치 완료!\x1b[0m');
+    console.log('  \x1b[2m시작하기: anpm login\x1b[0m');
+    console.log('');
+}

package/dist/prompts/_error-handling.md

@@ -0,0 +1,38 @@
+### 에러 처리 가이드
+
+CLI 명령 실행 후 JSON 에러가 반환되면 아래 기준에 따라 처리합니다.
+**원칙: "되돌릴 수 없는 영향이 있는가?"로 판단합니다.**
+
+#### 1. 자동 해결 (사용자에게 물어보지 않음)
+되돌릴 수 있고, 부작용 없는 에러:
+
+| 에러 코드 | 행동 |
+|-----------|------|
+| `LOGIN_REQUIRED` / `NO_TOKEN` | `anpm login` 실행 (timeout 300초, 브라우저 자동 열림) → 성공 후 원래 명령 재시도 |
+| `NOT_INITIALIZED` | `anpm init --all --json` 실행 → 원래 명령 재시도 |
+| `FETCH_FAILED` | 3초 대기 후 원래 명령 재시도 (최대 2회). 2회 실패 시 사용자에게 안내 |
+
+#### 2. 사용자에게 선택지 제시 (사용자 질문 도구)
+`options` 필드가 있는 에러:
+
+| 에러 코드 | 행동 |
+|-----------|------|
+| `MISSING_VISIBILITY` | options의 label을 선택지로 사용자 질문 도구 호출 |
+| `MISSING_FIELD` | fix 안내 + 사용자에게 값 입력 요청 |
+| `MISSING_TOOLS` | options의 감지된 도구 목록을 선택지로 사용자 질문 도구 호출 |
+| `MISSING_SPACE` | options의 Space 목록을 선택지로 사용자 질문 도구 호출 |
+
+사용자가 선택하면, 선택된 값을 CLI 플래그에 반영하여 명령을 재호출합니다.
+
+#### 3. 사용자에게 안내 (되돌릴 수 없는 에러)
+구매, 접근 권한, 보안 관련:
+
+| 에러 코드 | 행동 |
+|-----------|------|
+| `GATED_ACCESS_REQUIRED` | purchase_info의 message/url 표시 → "접근 코드가 있으신가요?" 사용자 질문 도구 호출 |
+| `SPACE_ONLY` | Space 가입 필요 안내 → "초대 코드가 있으신가요?" 사용자 질문 도구 호출 |
+| `APPROVAL_REQUIRED` | 승인 대기 안내 |
+| `NO_ACCESS` | 접근 방법 안내 |
+
+#### 4. 그 외 에러
+`fix` 필드의 메시지를 사용자에게 전달하고, 필요하면 다음 행동을 제안합니다.