pattyeng 1.0.6 → 1.0.9

package/README.md

@@ -1,26 +1,34 @@
 # pattyeng
 
-Patty 엔지니어용 작업 환경 도구.
+Patty 엔지니어용 작업 환경 도구입니다.
 
-새 노트북이든, WSL이든, 오래 방치한 개발환경이든 — Patty에서 일하는 데 필요한 기본 세팅을 한 번에 맞춥니다.
-
-지금은 Codex 설정, 스킬 동기화, 업그레이드를 담당합니다. 앞으로는 MCP, hooks, 공통 환경설정까지 같은 방식으로 붙일 예정입니다.
+처음 세팅, 업데이트, Codex 스킬 설치를 같은 명령어 체계로 관리합니다. 지금은 Codex 중심입니다. 나중에 MCP, hooks, 공통 환경설정도 여기에 붙일 수 있게 만들고 있습니다.
 
 ---
 
-## 설치
+## 빠른 시작
 
 ```bash
 npm install -g pattyeng
+pattyeng install codex
 ```
 
-설치 후 아래 명령어로 시작합니다.
+브라우저가 열리면 Patty 계정으로 로그인하세요.
+
+설치가 끝난 뒤 한 번만 터미널을 다시 불러오면 됩니다.
+
+macOS / Linux / WSL:
 
 ```bash
-pattyeng install codex
+exec zsh    # zsh
+exec bash   # bash
 ```
 
-브라우저가 열리면 Patty 계정으로 로그인하세요. 로그인 후 필요한 값은 자동으로 설정됩니다.
+Windows:
+
+```text
+터미널을 닫고 새로 열기
+```
 
 ---
 
@@ -28,37 +36,23 @@ pattyeng install codex
 
 ### `pattyeng install codex`
 
-Codex를 Patty 환경에 맞게 세팅합니다.
+Codex를 Patty 환경에 맞게 처음 세팅합니다.
 
-처리하는 일:
+하는 일:
 
 - Codex 설치 확인
 - Codex 최신 버전 업데이트
-- Patty 설정 파일 복사
+- `~/.codex/patty.config.toml` 설치
 - Patty SSO 로그인
-- `PATTY_AGENT_API_KEY` 등록
+- `PATTY_AGENT_API_KEY` 등록 (Keycloak userinfo claim 사용)
 - `codex` 명령어가 Patty 프로필을 쓰도록 설정
+- `~/.codex/skills`에 Patty 스킬 설치
 
-실행:
-
-```bash
-pattyeng install codex
-```
-
-마지막에 터미널만 다시 불러오면 됩니다.
-
-macOS / Linux / WSL:
-
-```bash
-exec zsh    # zsh 사용자
-exec bash   # bash 사용자
-```
-
-Windows:
+스킬 설치 규칙:
 
-```text
-터미널을 닫고 새로 열기
-```
+- 이미 같은 이름의 스킬 폴더가 있으면 **건너뜁니다**.
+- 기존 스킬을 덮어쓰지 않습니다.
+- 그래서 처음 세팅 때 안전하게 여러 번 실행해도 됩니다.
 
 ---
 
@@ -70,32 +64,46 @@ Windows:
 pattyeng upgrade
 ```
 
-업데이트 대상:
+하는 일:
+
+- npm에서 최신 `pattyeng` 패키지 다운로드
+- Codex CLI 최신 버전 업데이트
+- Patty 스킬 최신 버전으로 동기화
 
-- `pattyeng`
-- Codex CLI
+`upgrade`는 기존 스킬을 최신 버전으로 바꿉니다. 스킬 업데이트가 필요하면 보통 이 명령어만 쓰면 됩니다.
 
 ---
 
 ### `pattyeng skills list`
 
-현재 설치된 Codex 스킬을 봅니다.
+설치된 스킬 이름을 짧게 봅니다.
 
 ```bash
 pattyeng skills list
 ```
 
+설명까지 보고 싶으면:
+
+```bash
+pattyeng skills list --long
+```
+
 ---
 
 ### `pattyeng skills sync`
 
-Patty dotfiles에 있는 최신 스킬을 `~/.codex/skills`로 동기화합니다.
+스킬만 수동으로 동기화합니다.
 
 ```bash
 pattyeng skills sync
 ```
 
-스킬이 바뀌었거나 새로 추가됐을 때 실행하면 됩니다.
+보통은 직접 실행할 필요 없습니다.
+
+- 처음 세팅: `pattyeng install codex`
+- 업데이트: `pattyeng upgrade`
+
+위 두 명령어가 스킬까지 처리합니다.
 
 ---
 
@@ -107,11 +115,16 @@ pattyeng skills sync
 - Windows PowerShell
 - Windows CMD
 
-Node.js 18 이상이 필요합니다.
+필요 조건:
+
+- Node.js 18 이상
+- npm
+- Patty 계정
+- `pattyeng` 그룹 멤버십
 
 ---
 
-## 자주 나는 문제
+## 문제 해결
 
 ### 브라우저가 자동으로 안 열림
 
@@ -121,6 +134,10 @@ Node.js 18 이상이 필요합니다.
 
 Patty 관리자에게 `pattyeng` 그룹 추가를 요청하세요.
 
+### `PATTY_AGENT_API_KEY`를 찾을 수 없다고 나옴
+
+Keycloak `pattyeng` 그룹의 `PATTY_AGENT_API_KEY` 속성이 userinfo claim으로 매핑되어 있는지 확인하세요.
+
 ### 환경변수가 바로 안 잡힘
 
 새 터미널을 열거나 아래 명령어를 실행하세요.
@@ -133,9 +150,13 @@ exec bash
 
 Windows는 터미널을 닫고 새로 열면 됩니다.
 
-### Codex가 이상하게 동작함
+### 스킬을 다시 받고 싶음
+
+```bash
+pattyeng skills sync
+```
 
-한 번 업데이트하세요.
+### 전체를 최신으로 맞추고 싶음
 
 ```bash
 pattyeng upgrade
@@ -145,4 +166,4 @@ pattyeng upgrade
 
 ## 한 줄 요약
 
-Patty에서 쓰는 개발환경 세팅을 사람 손 덜 타게 만드는 도구입니다.
+Patty에서 쓰는 개발환경 세팅을 반복 작업이 아니라 명령어로 관리하게 만드는 도구입니다.

package/bin/pattyeng.js

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
 'use strict';
 
+process.stdout.on('error', (err) => {
+  if (err.code === 'EPIPE') process.exit(0);
+  throw err;
+});
+
 const { install } = require('../lib/install');
-const { upgrade } = require('../lib/upgrade');
+const { upgrade, applyUpgrade } = require('../lib/upgrade');
 const { skills }  = require('../lib/skills');
+const { printBanner } = require('../lib/banner');
 
 const args   = process.argv.slice(2);
 const cmd    = args[0];
@@ -23,6 +29,10 @@ async function main() {
       await upgrade();
       break;
 
+    case 'upgrade:apply':
+      await applyUpgrade();
+      break;
+
     case 'skills':
       await skills(args.slice(1));
       break;
@@ -33,16 +43,12 @@ async function main() {
 }
 
 function printHelp() {
-  console.log(`
-╔══════════════════════════════════════════╗
-║        pattyeng CLI                      ║
-╚══════════════════════════════════════════╝
-
-명령어:
-  install codex    Codex 설치 + SSO 로그인 + 환경설정
-  upgrade          pattyeng, Codex 최신 버전으로 업데이트
-  skills list      설치된 스킬 목록
-  skills sync      스킬 최신 버전으로 동기화
+  printBanner();
+  console.log(`명령어:
+  pattyeng install codex    Codex 설치 + SSO 로그인 + 스킬 설치
+  pattyeng upgrade          pattyeng + Codex + skills 업데이트
+  pattyeng skills list      설치된 스킬 목록
+  pattyeng skills sync      스킬 수동 동기화
 `);
 }
 

package/lib/banner.js

@@ -0,0 +1,19 @@
+'use strict';
+
+function banner(command = '') {
+  const suffix = command ? `  ${command}` : '';
+  return `
+██████╗  █████╗ ████████╗████████╗██╗   ██╗███████╗███╗   ██╗ ██████╗ 
+██╔══██╗██╔══██╗╚══██╔══╝╚══██╔══╝╚██╗ ██╔╝██╔════╝████╗  ██║██╔════╝ 
+██████╔╝███████║   ██║      ██║    ╚████╔╝ █████╗  ██╔██╗ ██║██║  ███╗
+██╔═══╝ ██╔══██║   ██║      ██║     ╚██╔╝  ██╔══╝  ██║╚██╗██║██║   ██║
+██║     ██║  ██║   ██║      ██║      ██║   ███████╗██║ ╚████║╚██████╔╝
+╚═╝     ╚═╝  ╚═╝   ╚═╝      ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═══╝ ╚═════╝ ${suffix}
+`;
+}
+
+function printBanner(command = '') {
+  process.stdout.write(banner(command));
+}
+
+module.exports = { banner, printBanner };

package/lib/install.js

@@ -1,12 +1,14 @@
 'use strict';
 
-const { execSync } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
 const fs = require('fs');
 const http = require('http');
 const https = require('https');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { installSkills } = require('./skills');
+const { printBanner } = require('./banner');
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 const KEYCLOAK_URL    = 'https://login.patty.io';
@@ -18,12 +20,9 @@ const CALLBACK_PATH   = '/pattyeng-callback';
 const TOKEN_URL    = `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/token`;
 const AUTH_URL     = `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/auth`;
 const USERINFO_URL = `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/userinfo`;
-// Admin API — read-only: only fetches pattyeng group attributes
+// Optional admin fallback. Do not ship admin credentials in the package.
 const ADMIN_TOKEN_URL  = `${KEYCLOAK_URL}/realms/master/protocol/openid-connect/token`;
 const PATTYENG_GROUP_ID = '058502d3-38cd-4ddb-84d7-0aad50a25f75';
-// Service account credentials (read-only group attribute access)
-const SA_USER = 'admin';
-const SA_PASS = 'pattyeng0805@';
 
 // ─── Platform ────────────────────────────────────────────────────────────────
 const IS_WIN  = process.platform === 'win32';
@@ -60,51 +59,51 @@ function generateCodeChallenge(verifier) {
 }
 
 // ─── Simple HTTPS GET/POST ────────────────────────────────────────────────────
-function httpsPost(url, body) {
+function parseJson(raw) {
+  if (!raw) return {};
+  try { return JSON.parse(raw); } catch { return raw; }
+}
+
+function requestJson(url, { method = 'GET', token = null, form = null } = {}) {
   return new Promise((resolve, reject) => {
     const parsed = new URL(url);
-    const data = typeof body === 'string' ? body : new URLSearchParams(body).toString();
-    const options = {
+    const data = form ? new URLSearchParams(form).toString() : null;
+    const headers = token ? { Authorization: `Bearer ${token}` } : {};
+    if (data) {
+      headers['Content-Type'] = 'application/x-www-form-urlencoded';
+      headers['Content-Length'] = Buffer.byteLength(data);
+    }
+
+    const req = https.request({
       hostname: parsed.hostname,
       path: parsed.pathname + parsed.search,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'Content-Length': Buffer.byteLength(data),
-      },
-    };
-    const req = https.request(options, (res) => {
+      method,
+      headers,
+    }, (res) => {
       let raw = '';
       res.on('data', (c) => raw += c);
       res.on('end', () => {
-        try { resolve(JSON.parse(raw)); } catch { resolve(raw); }
+        const payload = parseJson(raw);
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          const detail = payload && (payload.error_description || payload.error || payload.message);
+          reject(new Error(`HTTP ${res.statusCode}${detail ? `: ${detail}` : ''}`));
+          return;
+        }
+        resolve(payload);
       });
     });
     req.on('error', reject);
-    req.write(data);
+    if (data) req.write(data);
     req.end();
   });
 }
 
+function httpsPost(url, body) {
+  return requestJson(url, { method: 'POST', form: body });
+}
+
 function httpsGet(url, token) {
-  return new Promise((resolve, reject) => {
-    const parsed = new URL(url);
-    const options = {
-      hostname: parsed.hostname,
-      path: parsed.pathname + parsed.search,
-      method: 'GET',
-      headers: { 'Authorization': `Bearer ${token}` },
-    };
-    const req = https.request(options, (res) => {
-      let raw = '';
-      res.on('data', (c) => raw += c);
-      res.on('end', () => {
-        try { resolve(JSON.parse(raw)); } catch { resolve(raw); }
-      });
-    });
-    req.on('error', reject);
-    req.end();
-  });
+  return requestJson(url, { method: 'GET', token });
 }
 
 // ─── RC file helpers ──────────────────────────────────────────────────────────
@@ -132,6 +131,7 @@ function getRcFiles() {
 function appendToRc(block) {
   const firstLine = block.trim().split('\n')[0];
   for (const rc of getRcFiles()) {
+    fs.mkdirSync(path.dirname(rc), { recursive: true });
     const content = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
     if (!content.includes(firstLine)) {
       fs.appendFileSync(rc, '\n' + block + '\n');
@@ -142,6 +142,32 @@ function appendToRc(block) {
   }
 }
 
+function upsertRcBlock(marker, block) {
+  const markerLine = `# pattyeng — ${marker}`;
+  const markedBlock = `${markerLine}\n${block}`;
+  for (const rc of getRcFiles()) {
+    fs.mkdirSync(path.dirname(rc), { recursive: true });
+    const content = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+    const lines = content.split('\n');
+    const index = lines.findIndex(line => line.trim() === markerLine);
+    let next;
+    if (index === -1) {
+      next = `${content.replace(/\s*$/, '')}\n\n${markedBlock}\n`;
+    } else {
+      lines.splice(index, 2, markerLine, block);
+      next = lines.join('\n').replace(/\s*$/, '') + '\n';
+    }
+    fs.writeFileSync(rc, next);
+    log(`  → 설정됨: ${rc}`);
+  }
+}
+
+function escapeHtml(value) {
+  return String(value).replace(/[&<>"']/g, (ch) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+  }[ch]));
+}
+
 // ─── HTML pages ───────────────────────────────────────────────────────────────
 function successHtml() {
   return `<!DOCTYPE html>
@@ -185,7 +211,7 @@ function errorHtml(msg) {
   align-items:center;justify-content:center;min-height:100vh}
   .card{background:#16213e;border-radius:16px;padding:40px;max-width:480px;text-align:center}
   h1{color:#e94560}p{margin-top:16px;opacity:.8}</style></head>
-<body><div class="card"><h1>❌ 오류</h1><p>${msg}</p><p>터미널에서 오류를 확인하세요.</p></div></body></html>`;
+<body><div class="card"><h1>❌ 오류</h1><p>${escapeHtml(msg)}</p><p>터미널에서 오류를 확인하세요.</p></div></body></html>`;
 }
 
 // ─── Step 1: Install codex ────────────────────────────────────────────────────
@@ -223,15 +249,40 @@ function copyPattyConfig() {
     path.join(__dirname, '..', 'patty.config.toml'),
   ];
   const dest = path.join(codexDir, 'patty.config.toml');
-  let src = candidates.find(fs.existsSync);
+  const src = candidates.find(fs.existsSync);
 
-  if (src) {
-    fs.copyFileSync(src, dest);
-    ok(`복사 완료 → ${dest}`);
-  } else {
-    fs.writeFileSync(dest, '[model_providers.patty]\n');
-    warn(`원본 없음 → 기본 파일 생성: ${dest}`);
+  if (!src) {
+    throw new Error('patty.config.toml 원본을 찾을 수 없습니다. 패키지에 설정 파일이 포함되어야 합니다.');
   }
+
+  fs.copyFileSync(src, dest);
+  ok(`복사 완료 → ${dest}`);
+}
+
+function getPattyApiKey(userinfo) {
+  const value = userinfo.PATTY_AGENT_API_KEY || userinfo.patty_agent_api_key;
+  return Array.isArray(value) ? value[0] : value || null;
+}
+
+async function readApiKeyFromAdminApi() {
+  const username = process.env.PATTYENG_KEYCLOAK_ADMIN_USER;
+  const password = process.env.PATTYENG_KEYCLOAK_ADMIN_PASSWORD;
+  if (!username || !password) return null;
+
+  log('  → userinfo에 API 키 없음, 관리자 환경변수로 그룹 속성 조회 중...');
+  const adminTokenRes = await httpsPost(ADMIN_TOKEN_URL, {
+    grant_type: 'password',
+    client_id:  'admin-cli',
+    username,
+    password,
+  });
+  const groupData = await httpsGet(
+    `${KEYCLOAK_URL}/admin/realms/${REALM}/groups/${PATTYENG_GROUP_ID}`,
+    adminTokenRes.access_token
+  );
+  const attrs = groupData.attributes || {};
+  const value = attrs.PATTY_AGENT_API_KEY;
+  return Array.isArray(value) ? value[0] : value || null;
 }
 
 // ─── Step 4: OIDC PKCE Login ──────────────────────────────────────────────────
@@ -332,31 +383,14 @@ async function ssoLogin() {
         }
         log('  → pattyeng 그룹 확인 완료');
 
-        // Get PATTY_AGENT_API_KEY from userinfo claim (if mapper works)
-        // or fallback: read group attribute via admin API
-        let apiKey = userinfo.PATTY_AGENT_API_KEY || null;
+        let apiKey = getPattyApiKey(userinfo);
 
         if (!apiKey) {
-          log('  → userinfo에 API 키 없음, 그룹 속성에서 읽는 중...');
-          // Get admin token to read group attributes
-          const adminTokenRes = await httpsPost(ADMIN_TOKEN_URL, {
-            grant_type: 'password',
-            client_id:  'admin-cli',
-            username:   SA_USER,
-            password:   SA_PASS,
-          });
-          if (adminTokenRes.error) throw new Error('관리자 토큰 획득 실패: ' + adminTokenRes.error_description);
-          const groupData = await httpsGet(
-            `${KEYCLOAK_URL}/admin/realms/${REALM}/groups/${PATTYENG_GROUP_ID}`,
-            adminTokenRes.access_token
-          );
-          const attrs = groupData.attributes || {};
-          const vals = attrs.PATTY_AGENT_API_KEY || [];
-          apiKey = vals[0] || null;
+          apiKey = await readApiKeyFromAdminApi();
         }
 
         if (!apiKey) {
-          throw new Error('PATTY_AGENT_API_KEY를 그룹 속성에서 찾을 수 없습니다. 관리자에게 문의하세요.');
+          throw new Error('PATTY_AGENT_API_KEY를 찾을 수 없습니다. Keycloak userinfo 매퍼를 확인하세요.');
         }
 
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -398,18 +432,18 @@ function writeApiKeyToRc(apiKey) {
 
   if (IS_WIN) {
     // PowerShell profile (new PS sessions)
-    appendToRc(`# pattyeng — Patty Agent API Key\n$env:PATTY_AGENT_API_KEY = "${apiKey}"`);
+    upsertRcBlock('Patty Agent API Key', `$env:PATTY_AGENT_API_KEY = "${apiKey.replace(/"/g, '`"')}"`);
     // setx: Windows user-level env var — persists across ALL new terminals (cmd, PS, git bash)
     try {
-      execSync(`setx PATTY_AGENT_API_KEY "${apiKey}"`, { stdio: 'pipe' });
+      execFileSync('setx', ['PATTY_AGENT_API_KEY', apiKey], { stdio: 'pipe' });
       log('  → Windows 사용자 환경변수 등록 완료 (setx)');
     } catch (e) {
       warn('setx 실패: ' + e.message);
     }
   } else if (SHELL === 'fish') {
-    appendToRc(`# pattyeng — Patty Agent API Key\nset -Ux PATTY_AGENT_API_KEY "${apiKey}"`);
+    upsertRcBlock('Patty Agent API Key', `set -Ux PATTY_AGENT_API_KEY "${apiKey.replace(/"/g, '\\"')}"`);
   } else {
-    appendToRc(`# pattyeng — Patty Agent API Key\nexport PATTY_AGENT_API_KEY="${apiKey}"`);
+    upsertRcBlock('Patty Agent API Key', `export PATTY_AGENT_API_KEY="${apiKey.replace(/"/g, '\\"')}"`);
   }
 
   process.env.PATTY_AGENT_API_KEY = apiKey;
@@ -423,6 +457,7 @@ function addCodexAlias() {
   if (IS_WIN) {
     const block = `\n# pattyeng — codex alias\nfunction codex { codex.cmd -p patty $args }\n`;
     for (const rc of getRcFiles()) {
+      fs.mkdirSync(path.dirname(rc), { recursive: true });
       const content = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
       if (!content.includes('pattyeng — codex alias')) {
         fs.appendFileSync(rc, block);
@@ -436,16 +471,18 @@ function addCodexAlias() {
   }
 
   for (const rc of getRcFiles()) {
-    if (!fs.existsSync(rc)) continue;
+    fs.mkdirSync(path.dirname(rc), { recursive: true });
+    if (!fs.existsSync(rc)) fs.writeFileSync(rc, '');
     let content = fs.readFileSync(rc, 'utf8');
 
-    if (content.includes('-p patty')) {
+    const existingAlias = /^(alias codex=["'])(.*)(["'])\s*$/m;
+    const match = content.match(existingAlias);
+    if (match && /(?:^|\s)-p\s+patty(?:\s|$)/.test(match[2])) {
       log(`  → 이미 -p patty 포함: ${rc} (건너뜀)`);
       continue;
     }
 
-    const existingAlias = /^(alias codex=["'])(.*)(["'])\s*$/m;
-    if (existingAlias.test(content)) {
+    if (match) {
       content = content.replace(existingAlias, (_, pre, cmd, post) => {
         return `${pre}${cmd} -p patty${post}`;
       });
@@ -472,6 +509,7 @@ ${username ? `  👤 로그인: ${username}\n` : ''}
 ✅ 완료된 작업:
    • Codex 설치 및 최신 버전 업데이트
    • ~/.codex/patty.config.toml 복사
+   • Codex 스킬 설치
    • PATTY_AGENT_API_KEY 환경변수 등록
    • codex alias 등록 (codex = codex -p patty)
 
@@ -493,15 +531,12 @@ ${IS_WIN
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
 async function install() {
-  log(`
-╔══════════════════════════════════════════╗
-║   pattyeng install codex 시작            ║
-╚══════════════════════════════════════════╝
-`);
+  printBanner('install codex');
 
   installCodex();
   updateCodex();
   copyPattyConfig();
+  installSkills({ overwrite: false });
 
   let apiKey = null;
   let username = null;
@@ -512,10 +547,10 @@ async function install() {
     ok(`SSO 로그인 성공! (${username})`);
   } catch (e) {
     warn('SSO 로그인 실패: ' + e.message);
-    warn('PATTY_AGENT_API_KEY 등록을 건너뜁니다.');
+    throw new Error('설치를 완료할 수 없습니다. Patty SSO 로그인과 PATTY_AGENT_API_KEY 설정이 필요합니다.');
   }
 
-  if (apiKey) writeApiKeyToRc(apiKey);
+  writeApiKeyToRc(apiKey);
   addCodexAlias();
   finalMessage(username);
 }

package/lib/skills.js

@@ -1,33 +1,39 @@
 'use strict';
 
-const { execSync } = require('child_process');
 const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
+const { printBanner } = require('./banner');
 
-const HOME       = os.homedir();
-const DEST_DIR   = path.join(HOME, '.codex', 'skills');
+const HOME          = os.homedir();
+const DEST_DIR      = path.join(HOME, '.codex', 'skills');
+const MANIFEST_PATH = path.join(DEST_DIR, '.pattyeng-skills.json');
 
-// Source: npm registry tarball for pattyeng — skills are bundled inside package
-// Fallback: look for dotfiles repo next to package install location
 function findSourceSkillsDir() {
   const candidates = [
-    // bundled inside the npm package itself (skills/ at package root)
-    path.join(__dirname, '..', 'skills'),
-    // dotfiles repo sibling
-    path.join(__dirname, '..', '..', 'skills'),
+    path.join(__dirname, '..', 'skills'),          // bundled npm package
+    path.join(__dirname, '..', '..', 'skills'),    // dotfiles repo
     path.join(__dirname, '..', '..', 'dotfiles', 'skills'),
   ];
   return candidates.find(d => fs.existsSync(d) && fs.statSync(d).isDirectory()) || null;
 }
 
 function log(msg)  { process.stdout.write(msg + '\n'); }
-function step(msg) { log(`\n🔧 ${msg}`); }
-function ok(msg)   { log(`✅ ${msg}`); }
 function warn(msg) { log(`⚠️  ${msg}`); }
-function info(msg) { log(`   ${msg}`); }
 
-// Read SKILL.md name/description
+function cleanYamlScalar(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^[\'\"]|[\'\"]$/g, '')
+    .replace(/^>\s*/, '')
+    .trim();
+}
+
+function cleanDescription(value) {
+  const cleaned = cleanYamlScalar(value).replace(/\s+/g, ' ');
+  return cleaned.length > 82 ? cleaned.slice(0, 79) + '...' : cleaned;
+}
+
 function readSkillMeta(skillDir) {
   const mdPath = path.join(skillDir, 'SKILL.md');
   if (!fs.existsSync(mdPath)) return { name: path.basename(skillDir), description: '' };
@@ -35,136 +41,200 @@ function readSkillMeta(skillDir) {
   const nameMatch = content.match(/^name:\s*(.+)$/m);
   const descMatch = content.match(/^description:\s*(.+)$/m);
   return {
-    name:        nameMatch  ? nameMatch[1].trim()  : path.basename(skillDir),
-    description: descMatch  ? descMatch[1].trim().slice(0, 60) : '',
+    name: cleanYamlScalar(nameMatch ? nameMatch[1] : path.basename(skillDir)),
+    description: descMatch ? cleanYamlScalar(descMatch[1]) : '',
   };
 }
 
-// Diff two SKILL.md files — returns true if different
-function isDifferent(srcFile, destFile) {
-  if (!fs.existsSync(destFile)) return true;
-  return fs.readFileSync(srcFile, 'utf8') !== fs.readFileSync(destFile, 'utf8');
+function getSkillDirs(baseDir) {
+  if (!fs.existsSync(baseDir)) return [];
+  return fs.readdirSync(baseDir).filter(name => {
+    try { return fs.statSync(path.join(baseDir, name)).isDirectory(); }
+    catch { return false; }
+  }).sort();
 }
 
-// Copy a skill folder recursively
-function copySkill(srcDir, destDir) {
-  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
-  for (const file of fs.readdirSync(srcDir)) {
-    const src  = path.join(srcDir, file);
-    const dest = path.join(destDir, file);
-    if (fs.statSync(src).isDirectory()) {
-      copySkill(src, dest);
-    } else {
-      fs.copyFileSync(src, dest);
-    }
+function sameSymlink(dest, src) {
+  try {
+    return fs.lstatSync(dest).isSymbolicLink() && fs.realpathSync(dest) === fs.realpathSync(src);
+  } catch {
+    return false;
   }
 }
 
-async function skills(args) {
-  const sub = args[0];
+function removeExisting(dest) {
+  let st;
+  try { st = fs.lstatSync(dest); } catch { return; }
+  if (st.isDirectory() && !st.isSymbolicLink()) fs.rmSync(dest, { recursive: true, force: true });
+  else fs.unlinkSync(dest);
+}
 
-  if (!sub || sub === 'list') {
-    return listSkills();
-  }
-  if (sub === 'sync') {
-    return syncSkills();
+function readManifest() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+    return Array.isArray(parsed.skills) ? parsed.skills : [];
+  } catch {
+    return [];
   }
+}
 
-  log(`\n사용법:\n  pattyeng skills list   — 설치된 스킬 목록\n  pattyeng skills sync   — 스킬 최신 버전으로 동기화\n`);
+function writeManifest(skills) {
+  fs.writeFileSync(MANIFEST_PATH, `${JSON.stringify({ skills: [...skills].sort() }, null, 2)}\n`);
 }
 
-function listSkills() {
-  log(`\n📚 설치된 스킬 목록 (${DEST_DIR})\n`);
+function pruneDeletedSkills(srcSkills, { quiet }) {
+  const srcSet = new Set(srcSkills);
+  let removed = 0;
 
-  if (!fs.existsSync(DEST_DIR)) {
-    warn('~/.codex/skills 폴더가 없습니다. pattyeng skills sync 를 먼저 실행하세요.');
-    return;
+  for (const skill of readManifest()) {
+    if (srcSet.has(skill)) continue;
+    const dest = path.join(DEST_DIR, skill);
+    removeExisting(dest);
+    removed++;
+    if (!quiet) log(`  삭제: ${skill}`);
   }
 
-  const skills = fs.readdirSync(DEST_DIR).filter(f => {
-    try { return fs.statSync(path.join(DEST_DIR, f)).isDirectory(); }
-    catch { return false; } // broken symlink — skip
-  });
-
-  if (skills.length === 0) {
-    warn('스킬이 없습니다. pattyeng skills sync 를 실행하세요.');
-    return;
+  for (const name of fs.readdirSync(DEST_DIR)) {
+    const dest = path.join(DEST_DIR, name);
+    try {
+      if (fs.lstatSync(dest).isSymbolicLink()) fs.realpathSync(dest);
+    } catch {
+      removeExisting(dest);
+      removed++;
+      if (!quiet) log(`  깨진 링크 삭제: ${name}`);
+    }
   }
 
-  for (const skill of skills.sort()) {
-    const meta = readSkillMeta(path.join(DEST_DIR, skill));
-    const desc = meta.description ? `— ${meta.description}` : '';
-    log(`  • ${meta.name.padEnd(20)} ${desc}`);
+  return removed;
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src)) {
+    const from = path.join(src, entry);
+    const to = path.join(dest, entry);
+    const st = fs.statSync(from);
+    if (st.isDirectory()) copyDir(from, to);
+    else fs.copyFileSync(from, to);
   }
-  log('');
 }
 
-function syncSkills() {
-  log(`
-╔══════════════════════════════════════════╗
-║   pattyeng skills sync 시작              ║
-╚══════════════════════════════════════════╝
-`);
+function installSkillDir(src, dest, { overwrite }) {
+  let exists = false;
+  try { fs.lstatSync(dest); exists = true; } catch { exists = false; }
 
+  if (exists) {
+    if (!overwrite || sameSymlink(dest, src)) return 'skipped';
+    removeExisting(dest);
+  }
+
+  try {
+    fs.symlinkSync(src, dest, 'dir');
+  } catch {
+    // Windows without Developer Mode/Admin can reject symlinks. Copy instead.
+    copyDir(src, dest);
+  }
+  return 'installed';
+}
+
+function installSkills({ overwrite = false, quiet = false } = {}) {
   const srcDir = findSourceSkillsDir();
   if (!srcDir) {
     warn('스킬 소스 폴더를 찾을 수 없습니다.');
-    warn('dotfiles 저장소가 있어야 합니다: ~/projects/dotfiles/skills/');
-    process.exit(1);
+    return { added: 0, updated: 0, skipped: 0 };
   }
-  log(`  소스: ${srcDir}`);
-  log(`  대상: ${DEST_DIR}\n`);
 
   if (!fs.existsSync(DEST_DIR)) fs.mkdirSync(DEST_DIR, { recursive: true });
 
-  const srcSkills  = fs.readdirSync(srcDir).filter(f =>
-    fs.statSync(path.join(srcDir, f)).isDirectory()
-  );
+  if (!quiet) {
+    log(`\n📚 스킬 ${overwrite ? '동기화' : '설치'} 중...`);
+    log(`  소스: ${srcDir}`);
+    log(`  대상: ${DEST_DIR}\n`);
+  }
 
-  let added   = 0;
+  let added = 0;
   let updated = 0;
   let skipped = 0;
+  const srcSkills = getSkillDirs(srcDir);
+  const managedSkills = new Set(overwrite ? srcSkills : readManifest());
+  const removed = overwrite ? pruneDeletedSkills(srcSkills, { quiet }) : 0;
 
-  for (const skill of srcSkills.sort()) {
-    const src  = path.join(srcDir, skill);
+  for (const skill of srcSkills) {
+    const src = path.join(srcDir, skill);
     const dest = path.join(DEST_DIR, skill);
-    const meta = readSkillMeta(src);
-    const srcMd  = path.join(src, 'SKILL.md');
-    const destMd = path.join(dest, 'SKILL.md');
-
-    const destExists = fs.existsSync(dest);
-    const destLstat  = destExists ? null : null, lstat = (() => { try { return fs.lstatSync(dest); } catch { return null; } })();
-    const isSymlink  = lstat && lstat.isSymbolicLink();
-    const alreadyPointsHere = isSymlink && fs.readlinkSync(dest) === src;
-
-    if (!lstat) {
-      // doesn’t exist at all
-      fs.symlinkSync(src, dest);
-      log(`  ✨ 새로 추가: ${meta.name}`);
-      added++;
-    } else if (alreadyPointsHere) {
-      // already correct symlink
+    const name = readSkillMeta(src).name;
+    const existed = (() => { try { fs.lstatSync(dest); return true; } catch { return false; } })();
+    const result = installSkillDir(src, dest, { overwrite });
+
+    if (result === 'skipped') {
       skipped++;
-    } else if (isSymlink) {
-      // symlink pointing somewhere else — update
-      fs.unlinkSync(dest);
-      fs.symlinkSync(src, dest);
-      log(`  🔄 업데이트: ${meta.name}`);
-      updated++;
-    } else if (isDifferent(srcMd, destMd)) {
-      // real dir with changed content — overwrite
-      copySkill(src, dest);
-      log(`  🔄 업데이트: ${meta.name}`);
+      if (!quiet) log(`  건너뜀: ${name}`);
+    } else if (existed) {
       updated++;
+      managedSkills.add(skill);
+      if (!quiet) log(`  업데이트: ${name}`);
     } else {
-      skipped++;
+      added++;
+      managedSkills.add(skill);
+      if (!quiet) log(`  설치: ${name}`);
+    }
+  }
+
+  writeManifest(managedSkills);
+
+  if (!quiet) log(`\n  설치: ${added}개   업데이트: ${updated}개   건너뜀: ${skipped}개   삭제: ${removed}개`);
+  return { added, updated, skipped, removed };
+}
+
+async function skills(args) {
+  const sub = args[0];
+
+  if (!sub || sub === 'list') return listSkills(args.includes('--long'));
+  if (sub === 'sync') return syncSkills();
+
+  log(`\n사용법:\n  pattyeng skills list          — 스킬 이름만 보기\n  pattyeng skills list --long   — 설명까지 보기\n  pattyeng skills sync          — 스킬 최신 버전으로 동기화\n`);
+}
+
+function listSkills(long = false) {
+  log(`\n📚 스킬 목록 (${DEST_DIR})\n`);
+
+  if (!fs.existsSync(DEST_DIR)) {
+    warn('~/.codex/skills 폴더가 없습니다. pattyeng skills sync 를 먼저 실행하세요.');
+    return;
+  }
+
+  const names = getSkillDirs(DEST_DIR)
+    .map(skill => readSkillMeta(path.join(DEST_DIR, skill)).name)
+    .filter(name => !name.startsWith('.'));
+
+  if (names.length === 0) {
+    warn('스킬이 없습니다. pattyeng skills sync 를 실행하세요.');
+    return;
+  }
+
+  if (!long) {
+    const width = Math.max(18, ...names.map(n => n.length + 2));
+    for (let i = 0; i < names.length; i += 3) {
+      log('  ' + names.slice(i, i + 3).map(n => n.padEnd(width)).join(''));
     }
+    log(`\n  총 ${names.length}개. 설명 보기: pattyeng skills list --long\n`);
+    return;
   }
 
-  log(`
-  추가: ${added}개   업데이트: ${updated}개   변경없음: ${skipped}개
+  for (const skill of getSkillDirs(DEST_DIR)) {
+    const meta = readSkillMeta(path.join(DEST_DIR, skill));
+    if (meta.name.startsWith('.')) continue;
+    const desc = cleanDescription(meta.description);
+    log(`  • ${meta.name.padEnd(20)} ${desc ? `— ${desc}` : ''}`);
+  }
+  log('');
+}
 
-✅ 스킬 동기화 완료`);
+function syncSkills() {
+  printBanner('skills sync');
+  const result = installSkills({ overwrite: true });
+  log('\n✅ 스킬 동기화 완료');
+  return result;
 }
 
-module.exports = { skills };
+module.exports = { skills, installSkills, syncSkills };

package/lib/upgrade.js

@@ -1,46 +1,58 @@
 'use strict';
 
 const { execSync } = require('child_process');
+const { syncSkills } = require('./skills');
+const { printBanner } = require('./banner');
 
 function log(msg)  { process.stdout.write(msg + '\n'); }
 function step(msg) { log(`\n🔧 ${msg}`); }
 function ok(msg)   { log(`✅ ${msg}`); }
 function warn(msg) { log(`⚠️  ${msg}`); }
 
+function npmInstallLatest(packageName) {
+  execSync(`npm install -g ${packageName}@latest`, { stdio: 'inherit' });
+}
+
 async function upgrade() {
-  log(`
-╔══════════════════════════════════════════╗
-║   pattyeng upgrade 시작                  ║
-╚══════════════════════════════════════════╝
-`);
-
-  // 1. pattyeng itself
-  step('pattyeng 최신 버전으로 업데이트 중...');
+  printBanner('upgrade');
+
+  step('pattyeng 최신 패키지 다운로드 중...');
   try {
-    const before = execSync('npm list -g pattyeng --depth=0 2>/dev/null', { encoding: 'utf8' }).trim();
-    execSync('npm install -g pattyeng@latest', { stdio: 'inherit' });
-    const after = execSync('npm list -g pattyeng --depth=0 2>/dev/null', { encoding: 'utf8' }).trim();
-    if (before !== after) {
-      ok('pattyeng 업데이트 완료');
-    } else {
-      ok('pattyeng 이미 최신 버전');
-    }
+    npmInstallLatest('pattyeng');
+    ok('pattyeng 최신 패키지 설치 완료');
   } catch (e) {
     warn('pattyeng 업데이트 실패: ' + e.message);
+    warn('현재 설치된 버전으로 나머지 작업을 계속합니다.');
+    return applyUpgrade();
+  }
+
+  step('새로 설치된 pattyeng으로 upgrade 적용 중...');
+  try {
+    execSync('pattyeng upgrade:apply', { stdio: 'inherit' });
+  } catch (e) {
+    warn('새 pattyeng 실행 실패: ' + e.message);
+    warn('현재 프로세스로 upgrade 적용을 계속합니다.');
+    await applyUpgrade();
   }
+}
 
-  // 2. codex
+async function applyUpgrade() {
   step('Codex 최신 버전으로 업데이트 중...');
   try {
-    execSync('npm install -g @openai/codex@latest', { stdio: 'inherit' });
+    npmInstallLatest('@openai/codex');
     ok('Codex 업데이트 완료');
   } catch (e) {
     warn('Codex 업데이트 실패: ' + e.message);
   }
 
-  log(`
-✨ 업그레이드 완료!
-`);
+  step('스킬 최신 버전으로 동기화 중...');
+  try {
+    syncSkills();
+  } catch (e) {
+    warn('스킬 동기화 실패: ' + e.message);
+  }
+
+  log(`\n✨ 업그레이드 완료!\n`);
 }
 
-module.exports = { upgrade };
+module.exports = { upgrade, applyUpgrade };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "pattyeng",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "description": "Patty Engineering CLI - Codex SSO setup tool",
   "bin": {
-    "pattyeng": "./bin/pattyeng.js"
+    "pattyeng": "bin/pattyeng.js"
   },
   "main": "./lib/index.js",
   "scripts": {
-    "test": "echo \"No tests yet\""
+    "test": "node test/skills.test.js"
   },
   "dependencies": {
     "open": "^10.1.0"
@@ -29,6 +29,7 @@
     "bin",
     "lib",
     "skills",
-    "README.md"
+    "patty.config.toml",
+    "test"
   ]
 }

package/patty.config.toml

@@ -0,0 +1,18 @@
+model = "pattyeng"
+model_reasoning_effort = "xhigh"
+model_provider = "patty"
+
+[features]
+multi_agent = true
+codex_hooks = true
+
+[agents]
+max_threads = 6
+max_depth = 2
+
+[model_providers.patty]
+name = "GPT"
+base_url = "https://jebo.ai/v1"
+wire_api = "responses"
+env_key = "PATTY_AGENT_API_KEY"
+stream_idle_timeout_ms = 300000

package/test/skills.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pattyeng-skills-'));
+process.env.HOME = tmp;
+
+const { installSkills } = require('../lib/skills');
+
+const destDir = path.join(tmp, '.codex', 'skills');
+fs.mkdirSync(path.join(destDir, 'cap'), { recursive: true });
+fs.writeFileSync(path.join(destDir, 'cap', 'SKILL.md'), '---\nname: cap-user\ndescription: user-owned\n---\n');
+
+const first = installSkills({ overwrite: false, quiet: true });
+assert(first.added > 0, 'first install should add packaged skills');
+assert(first.skipped >= 1, 'first install should skip pre-existing cap skill');
+
+let manifest = JSON.parse(fs.readFileSync(path.join(destDir, '.pattyeng-skills.json'), 'utf8')).skills;
+assert(!manifest.includes('cap'), 'install mode must not mark skipped user-owned cap as managed');
+
+const second = installSkills({ overwrite: false, quiet: true });
+assert.strictEqual(second.added, 0, 'second install should not add duplicate skills');
+assert(second.skipped > 0, 'second install should skip existing skills');
+
+const upgraded = installSkills({ overwrite: true, quiet: true });
+assert(upgraded.updated >= 1, 'overwrite sync should update pre-existing skills');
+manifest = JSON.parse(fs.readFileSync(path.join(destDir, '.pattyeng-skills.json'), 'utf8')).skills;
+assert(manifest.includes('cap'), 'sync mode should mark upstream cap as managed after overwrite');
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log('skills.test.js ok');