jutell 0.3.0

package/dist/installer/claude.js

@@ -0,0 +1,160 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { readText } from '../config/managed.js';
+import { claudeHome } from '../config/paths.js';
+export const CLAUDE_MCP_KEY = 'jutell';
+function normalizeForCompare(value) {
+    return value.replace(/\\/g, '/').toLowerCase();
+}
+/**
+ * Real Claude Code has no per-project `.codex`-style file: `local` scope
+ * (JuTell's `--project`, the default) and `user` scope (JuTell `--global`)
+ * both live in the *same* `.claude.json`, keyed either by the exact
+ * project path (`projects[path].mcpServers`) or at the top level
+ * (`mcpServers`). Verified empirically with an isolated `CLAUDE_CONFIG_DIR`
+ * across all three of Claude's own scopes (local/user/project); `project`
+ * (`.mcp.json`, git-shared) was not chosen for JuTell because Claude leaves
+ * servers registered there `⏸ Pending approval` until a human approves them
+ * in an interactive session - that would violate "no manual config
+ * hacking" for the very first connection.
+ */
+function claudeScopeFor(paths) {
+    return paths.scope === 'global' ? 'user' : 'local';
+}
+async function readClaudeConfig(paths) {
+    const text = await readText(paths.claudeConfigFile);
+    if (!text || !text.trim())
+        return {};
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function findMcpServers(config, paths) {
+    if (claudeScopeFor(paths) === 'user') {
+        const top = config.mcpServers;
+        return top && typeof top === 'object' && !Array.isArray(top) ? top : undefined;
+    }
+    const projects = config.projects;
+    if (!projects || typeof projects !== 'object' || Array.isArray(projects))
+        return undefined;
+    const target = normalizeForCompare(paths.targetRoot);
+    for (const [key, value] of Object.entries(projects)) {
+        if (normalizeForCompare(key) !== target)
+            continue;
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return undefined;
+        const mcp = value.mcpServers;
+        return mcp && typeof mcp === 'object' && !Array.isArray(mcp) ? mcp : undefined;
+    }
+    return undefined;
+}
+function expectedCommand(packageRoot) {
+    return { command: process.execPath, args: [path.join(packageRoot, 'assets', 'mcp-server', 'index.js')] };
+}
+function commandMatches(entry, packageRoot) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+        return false;
+    const value = entry;
+    const { command } = expectedCommand(packageRoot);
+    if (value.command !== command)
+        return false;
+    const args = Array.isArray(value.args) ? value.args : [];
+    return args.some((a) => typeof a === 'string' && a.includes('mcp-server'));
+}
+export function buildClaudePreview(claudeScope, packageRoot) {
+    const { command, args } = expectedCommand(packageRoot);
+    return JSON.stringify({ scope: claudeScope, type: 'stdio', command, args }, null, 2);
+}
+export async function readClaudeRegistration(paths, packageRoot, _enabled) {
+    const claudeScope = claudeScopeFor(paths);
+    const config = await readClaudeConfig(paths);
+    const servers = config ? findMcpServers(config, paths) : undefined;
+    const entry = servers?.[CLAUDE_MCP_KEY];
+    const registered = entry !== undefined;
+    // The `jutell` key is reserved across every JuTell provider adapter, so
+    // any existing entry under that name is treated as ours to manage
+    // (refreshed in place if its command/args drifted) rather than a
+    // conflict - unlike Codex/OpenCode, Claude has no historical legacy key
+    // to coexist with here (this is a brand-new adapter; providers.ts had it
+    // marked `planned` until this cycle, so no prior Claude JuTell state
+    // exists to preserve).
+    return {
+        file: paths.claudeConfigFile,
+        claudeScope,
+        exists: Boolean(config && Object.keys(config).length > 0),
+        registered,
+        conflict: false,
+        enabled: registered,
+        canonicalRegistered: registered,
+        legacyRegistered: false,
+        bothRegistered: false,
+        preview: buildClaudePreview(claudeScope, packageRoot),
+    };
+}
+// Windows can only launch the `claude` npm shim (a .cmd file) through a
+// shell, but `execFileSync`'s shell mode does not itself quote arguments -
+// it just space-joins them, so any argument containing a space (a `node.exe`
+// path under "Program Files", for instance) silently gets cut at the first
+// space. Quote every argument ourselves before it reaches cmd.exe.
+function quoteForWindowsShell(value) {
+    if (value === '')
+        return '""';
+    if (!/[\s"^&|<>()]/.test(value))
+        return value;
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function runClaude(args, paths) {
+    const isWindows = process.platform === 'win32';
+    return execFileSync('claude', isWindows ? args.map(quoteForWindowsShell) : args, {
+        cwd: paths.targetRoot,
+        env: { ...process.env, CLAUDE_CONFIG_DIR: claudeHome() },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: isWindows,
+        encoding: 'utf8',
+    });
+}
+export async function registerClaudeMcp(paths, packageRoot, enabled) {
+    const current = await readClaudeRegistration(paths, packageRoot, enabled);
+    const config = await readClaudeConfig(paths);
+    if (config === undefined)
+        throw new Error('Claude Code 설정 파일을 읽지 못해 자동 변경하지 않았습니다.');
+    const servers = findMcpServers(config, paths);
+    const claudeScope = current.claudeScope;
+    if (current.registered && commandMatches(servers?.[CLAUDE_MCP_KEY], packageRoot))
+        return current; // idempotent, already correct
+    if (current.registered) {
+        // Existing `jutell` entry points somewhere else (stale reinstall) -
+        // refresh it in place rather than leaving two inconsistent states.
+        try {
+            runClaude(['mcp', 'remove', '-s', claudeScope, CLAUDE_MCP_KEY], paths);
+        }
+        catch { /* fall through to add */ }
+    }
+    const { command, args } = expectedCommand(packageRoot);
+    try {
+        runClaude(['mcp', 'add', '-s', claudeScope, CLAUDE_MCP_KEY, '--', command, ...args], paths);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Claude Code MCP 등록에 실패했습니다: ${message}`);
+    }
+    return readClaudeRegistration(paths, packageRoot, enabled);
+}
+export async function removeClaudeMcp(paths, packageRoot) {
+    const current = await readClaudeRegistration(paths, packageRoot, false);
+    if (!current.registered)
+        return current;
+    try {
+        runClaude(['mcp', 'remove', '-s', current.claudeScope, CLAUDE_MCP_KEY], paths);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Claude Code MCP 제거에 실패했습니다: ${message}`);
+    }
+    return readClaudeRegistration(paths, packageRoot, false);
+}

package/dist/installer/config.js

@@ -0,0 +1,45 @@
+import { promises as fs } from 'node:fs';
+import { backupFile, readBridgeConfig, writeBridgeConfig, writeTextSafely } from '../config/managed.js';
+async function readObject(paths) {
+    try {
+        const raw = await fs.readFile(paths.configFile, 'utf8');
+        const value = JSON.parse(raw);
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function ensureBridgeConfig(paths, profile) {
+    const loaded = await readBridgeConfig(paths);
+    const current = await readObject(paths);
+    if (!current || !loaded.valid) {
+        const next = { ...loaded.config, ...(profile ? { profile } : {}) };
+        await writeBridgeConfig(paths, next);
+        return { config: next, created: true, replacedInvalid: loaded.exists && !loaded.valid };
+    }
+    const next = {
+        ...current,
+        version: 1,
+        ...(profile ? { profile } : {}),
+        mcp: (() => { const m = current.mcp; return { enabled: m?.enabled === true }; })(),
+    };
+    const before = JSON.stringify(current, null, 2);
+    const after = JSON.stringify(next, null, 2);
+    if (before !== after)
+        await writeTextSafely(paths.configFile, `${after}\n`);
+    return { config: next, created: false, replacedInvalid: false };
+}
+export async function setMcpEnabled(paths, enabled) {
+    const loaded = await readBridgeConfig(paths);
+    const current = await readObject(paths);
+    const next = { ...(current ?? loaded.config), version: 1, mcp: { ...(loaded.config.mcp ?? { enabled: false }), enabled } };
+    await writeBridgeConfig(paths, next);
+    return next;
+}
+export async function setMcpDisabled(paths) {
+    return setMcpEnabled(paths, false);
+}
+export async function backupBridgeConfig(paths) {
+    await backupFile(paths.configFile);
+}

package/dist/installer/opencode.js

@@ -0,0 +1,237 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { backupFile, exists, readText, writeTextSafely } from '../config/managed.js';
+export const OPENCODE_BEGIN_MARKER = 'BEGIN JUTELL MANAGED BLOCK';
+export const OPENCODE_END_MARKER = 'END JUTELL MANAGED BLOCK';
+export const OPENCODE_MCP_KEY = 'jutell';
+export const LEGACY_OPENCODE_MCP_KEY = 'beginner_bridge';
+function stripJsoncComments(text) {
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    let inLine = false;
+    let inBlock = false;
+    for (let i = 0; i < text.length; i += 1) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (inBlock) {
+            if (c === '*' && next === '/') {
+                inBlock = false;
+                out += '  ';
+                i += 1;
+            }
+            else
+                out += c === '\n' ? '\n' : ' ';
+            continue;
+        }
+        if (inLine) {
+            if (c === '\n') {
+                inLine = false;
+                out += '\n';
+            }
+            else
+                out += ' ';
+            continue;
+        }
+        if (inString) {
+            out += c;
+            if (escaped)
+                escaped = false;
+            else if (c === '\\')
+                escaped = true;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === '/' && next === '/') {
+            inLine = true;
+            out += '  ';
+            i += 1;
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            inBlock = true;
+            out += '  ';
+            i += 1;
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+function tryParseJson(text) {
+    const trimmed = (text ?? '').trim();
+    if (!trimmed)
+        return {};
+    try {
+        const cleaned = stripJsoncComments(trimmed).replace(/,\s*([}\]])/g, '$1');
+        const value = JSON.parse(cleaned);
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function opencodeDetected() {
+    const result = spawnSync('opencode', ['--version'], { stdio: 'ignore', windowsHide: true, shell: process.platform === 'win32' || undefined });
+    return result.status === 0 && !result.error;
+}
+export async function resolveOpenCodeConfigFile(paths) {
+    const directory = path.dirname(paths.opencodeConfigFile);
+    for (const name of ['opencode.jsonc', 'opencode.json']) {
+        const file = path.join(directory, name);
+        if (await exists(file))
+            return file;
+    }
+    return paths.opencodeConfigFile;
+}
+function serverEntry(packageRoot) {
+    return path.join(packageRoot, 'assets', 'mcp-server', 'index.js');
+}
+export function buildOpenCodeBlock(packageRoot, enabled) {
+    const entry = { type: 'local', command: [process.execPath, serverEntry(packageRoot)], enabled, cwd: '.' };
+    return JSON.stringify(entry, null, 2);
+}
+function indentLines(value, prefix) {
+    return value.replace(/\n/g, `\n${prefix}`);
+}
+function serializeWithManaged(config, enabled, packageRoot) {
+    const copy = { ...config };
+    const rawMcp = copy.mcp && typeof copy.mcp === 'object' && !Array.isArray(copy.mcp) ? copy.mcp : {};
+    const others = Object.entries(rawMcp).filter(([key]) => key !== OPENCODE_MCP_KEY);
+    const lines = ['{'];
+    for (const [key, value] of Object.entries(copy)) {
+        if (key === 'mcp')
+            continue;
+        lines.push(`  ${JSON.stringify(key)}: ${indentLines(JSON.stringify(value, null, 2), '  ')},`);
+    }
+    lines.push('  "mcp": {');
+    for (const [key, value] of others) {
+        lines.push(`    ${JSON.stringify(key)}: ${indentLines(JSON.stringify(value, null, 2), '    ')},`);
+    }
+    lines.push(`    // ${OPENCODE_BEGIN_MARKER}`);
+    lines.push(`    ${JSON.stringify(OPENCODE_MCP_KEY)}: ${indentLines(buildOpenCodeBlock(packageRoot, enabled), '    ')},`);
+    lines.push(`    // ${OPENCODE_END_MARKER}`);
+    lines.push('  }');
+    lines.push('}');
+    return lines.join('\n');
+}
+export async function readOpenCodeRegistration(paths, packageRoot, enabled) {
+    const file = await resolveOpenCodeConfigFile(paths);
+    const text = await readText(file) ?? '';
+    const parsed = tryParseJson(text);
+    const rawMcp = parsed?.mcp && typeof parsed.mcp === 'object' && !Array.isArray(parsed.mcp) ? parsed.mcp : {};
+    const canonicalEntry = rawMcp[OPENCODE_MCP_KEY];
+    const legacyEntry = rawMcp[LEGACY_OPENCODE_MCP_KEY];
+    const begin = text.indexOf(`// ${OPENCODE_BEGIN_MARKER}`);
+    const end = text.indexOf(`// ${OPENCODE_END_MARKER}`);
+    const managedText = begin >= 0 && end > begin ? text.slice(begin, end) : '';
+    const canonicalManaged = managedText.includes(JSON.stringify(OPENCODE_MCP_KEY));
+    const legacyManaged = managedText.includes(JSON.stringify(LEGACY_OPENCODE_MCP_KEY));
+    const canonicalRegistered = canonicalEntry !== undefined;
+    const legacyRegistered = legacyEntry !== undefined;
+    function isJuTellEntry(entry) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return false;
+        const cmd = entry.command;
+        if (!Array.isArray(cmd))
+            return false;
+        return cmd.some((c) => typeof c === 'string' && /(?:assets|apps)[\\/]mcp-server/i.test(c));
+    }
+    const canonicalHeuristic = !canonicalManaged && canonicalRegistered && isJuTellEntry(canonicalEntry);
+    const legacyHeuristic = !legacyManaged && legacyRegistered && isJuTellEntry(legacyEntry);
+    const registered = canonicalManaged || legacyManaged || canonicalHeuristic || legacyHeuristic;
+    const conflict = !registered && (canonicalRegistered || legacyRegistered);
+    const enabledFlag = (() => {
+        if (canonicalManaged && canonicalEntry && typeof canonicalEntry === 'object')
+            return canonicalEntry.enabled === true;
+        if (canonicalHeuristic && canonicalEntry && typeof canonicalEntry === 'object')
+            return canonicalEntry.enabled === true;
+        return false;
+    })();
+    return {
+        file,
+        exists: text.trim().length > 0,
+        registered,
+        conflict,
+        enabled: enabledFlag,
+        canonicalRegistered,
+        legacyRegistered,
+        bothRegistered: canonicalRegistered && legacyRegistered,
+        preview: serializeWithManaged(parsed ?? {}, enabled, packageRoot),
+    };
+}
+async function writeConfig(file, text) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await writeTextSafely(file, text);
+}
+export async function registerOpenCodeMcp(paths, packageRoot, enabled) {
+    const current = await readOpenCodeRegistration(paths, packageRoot, enabled);
+    if (current.conflict)
+        throw new Error('OpenCode 설정에 같은 이름의 관리되지 않는 MCP 항목이 있어 자동 변경하지 않았습니다.');
+    if (current.canonicalRegistered && current.enabled === enabled)
+        return current;
+    const text = await readText(current.file) ?? '';
+    const parsed = tryParseJson(text);
+    if (text.trim() && !parsed)
+        throw new Error('OpenCode 설정 파일을 읽지 못해 자동 변경하지 않았습니다.');
+    const base = parsed ?? { $schema: 'https://opencode.ai/config.json' };
+    await backupFile(current.file);
+    await writeConfig(current.file, `${serializeWithManaged(base, enabled, packageRoot)}\n`);
+    return readOpenCodeRegistration(paths, packageRoot, enabled);
+}
+export async function setOpenCodeEnabled(paths, packageRoot, enabled) {
+    const current = await readOpenCodeRegistration(paths, packageRoot, enabled);
+    if (current.conflict || !current.registered)
+        return current;
+    if (!current.canonicalRegistered || current.enabled === enabled)
+        return current;
+    await backupFile(current.file);
+    const text = await readText(current.file) ?? '';
+    const parsed = tryParseJson(text);
+    if (!parsed)
+        throw new Error('OpenCode 설정 파일을 읽지 못해 자동 변경하지 않았습니다.');
+    const copy = { ...parsed };
+    const rawMcp = copy.mcp && typeof copy.mcp === 'object' && !Array.isArray(copy.mcp) ? copy.mcp : {};
+    const mcpCopy = { ...rawMcp };
+    delete mcpCopy[OPENCODE_MCP_KEY];
+    if (Object.keys(mcpCopy).length === 0)
+        delete copy.mcp;
+    else
+        copy.mcp = mcpCopy;
+    await writeConfig(current.file, `${serializeWithManaged(copy, enabled, packageRoot)}\n`);
+    return readOpenCodeRegistration(paths, packageRoot, enabled);
+}
+export async function removeOpenCodeMcp(paths, packageRoot) {
+    const current = await readOpenCodeRegistration(paths, packageRoot, false);
+    if (current.conflict)
+        throw new Error('관리되지 않는 같은 이름의 OpenCode MCP 항목은 자동으로 제거하지 않습니다.');
+    if (!current.registered)
+        return current;
+    await backupFile(current.file);
+    const text = await readText(current.file) ?? '';
+    const parsed = tryParseJson(text);
+    if (!parsed)
+        throw new Error('OpenCode 설정 파일을 읽지 못해 자동 변경하지 않았습니다.');
+    const copy = { ...parsed };
+    const rawMcp = copy.mcp && typeof copy.mcp === 'object' && !Array.isArray(copy.mcp) ? copy.mcp : {};
+    const begin = text.indexOf(`// ${OPENCODE_BEGIN_MARKER}`);
+    const end = text.indexOf(`// ${OPENCODE_END_MARKER}`);
+    const managedText = begin >= 0 && end > begin ? text.slice(begin, end) : '';
+    if (managedText.includes(JSON.stringify(OPENCODE_MCP_KEY)))
+        delete rawMcp[OPENCODE_MCP_KEY];
+    if (managedText.includes(JSON.stringify(LEGACY_OPENCODE_MCP_KEY)))
+        delete rawMcp[LEGACY_OPENCODE_MCP_KEY];
+    if (Object.keys(rawMcp).length === 0)
+        delete copy.mcp;
+    else
+        copy.mcp = rawMcp;
+    await writeConfig(current.file, `${JSON.stringify(copy, null, 2)}\n`);
+    return readOpenCodeRegistration(paths, packageRoot, false);
+}

package/dist/installer/providers.js

@@ -0,0 +1,15 @@
+export const AGENT_PROVIDERS = [
+    { id: 'codex', label: 'Codex', status: 'supported', description: '현재 실제 연결을 지원합니다.' },
+    { id: 'opencode', label: 'OpenCode', status: 'beta', description: '로컬 stdio MCP 등록을 베타로 지원합니다.' },
+    { id: 'claude-code', label: 'Claude Code', status: 'beta', description: 'MCP 등록을 베타로 지원합니다.', aliases: ['claude'] },
+    { id: 'cline', label: 'Cline', status: 'planned', description: '연결 준비 중입니다.' },
+];
+export function findProvider(id) {
+    return AGENT_PROVIDERS.find((provider) => provider.id === id || provider.aliases?.includes(id));
+}
+export function supportedProviders() {
+    return AGENT_PROVIDERS.filter((provider) => provider.status !== 'planned');
+}
+export function supportedProviderNames() {
+    return supportedProviders().map((provider) => provider.label).join('와 ');
+}

package/dist/installer/skill.js

@@ -0,0 +1,94 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { exists, readText, writeTextSafely } from '../config/managed.js';
+async function filesUnder(root, current = root) {
+    if (!(await exists(current)))
+        return [];
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const file = path.join(current, entry.name);
+        if (entry.isDirectory())
+            files.push(...await filesUnder(root, file));
+        else
+            files.push(path.relative(root, file));
+    }
+    return files;
+}
+export async function installSkill(source, destination) {
+    const conflicts = [];
+    const changed = [];
+    for (const relative of await filesUnder(source)) {
+        const sourceFile = path.join(source, relative);
+        const targetFile = path.join(destination, relative);
+        const sourceContent = await fs.readFile(sourceFile);
+        let targetContent;
+        try {
+            targetContent = await fs.readFile(targetFile);
+        }
+        catch { /* new file */ }
+        if (targetContent && !targetContent.equals(sourceContent)) {
+            conflicts.push(relative);
+            continue;
+        }
+        if (!targetContent) {
+            await fs.mkdir(path.dirname(targetFile), { recursive: true });
+            await fs.copyFile(sourceFile, targetFile);
+            changed.push(relative);
+        }
+    }
+    return { conflicts, changed };
+}
+function manifestFile(paths) {
+    return path.join(paths.dataRoot, 'cli-install.json');
+}
+async function readManifest(paths) {
+    const raw = await readText(manifestFile(paths));
+    if (!raw)
+        return { skillFiles: [] };
+    try {
+        const value = JSON.parse(raw);
+        return { skillFiles: Array.isArray(value.skillFiles) ? value.skillFiles.filter((item) => typeof item === 'string') : [] };
+    }
+    catch {
+        return { skillFiles: [] };
+    }
+}
+export async function recordSkillFiles(paths, relativeFiles) {
+    if (relativeFiles.length === 0)
+        return;
+    const current = await readManifest(paths);
+    await fs.mkdir(paths.dataRoot, { recursive: true });
+    await writeTextSafely(manifestFile(paths), `${JSON.stringify({ skillFiles: [...new Set([...current.skillFiles, ...relativeFiles])] }, null, 2)}\n`);
+}
+export async function removeManagedSkillFiles(source, destination, paths) {
+    const manifest = await readManifest(paths);
+    const removed = [];
+    for (const relative of manifest.skillFiles) {
+        const sourceFile = path.join(source, relative);
+        const targetFile = path.join(destination, relative);
+        try {
+            const [sourceContent, targetContent] = await Promise.all([fs.readFile(sourceFile), fs.readFile(targetFile)]);
+            if (!sourceContent.equals(targetContent))
+                continue;
+            await fs.rm(targetFile, { force: true });
+            removed.push(relative);
+        }
+        catch { /* already absent or user file differs */ }
+    }
+    for (const relative of [...manifest.skillFiles].reverse()) {
+        const directory = path.dirname(path.join(destination, relative));
+        try {
+            if ((await fs.readdir(directory)).length === 0)
+                await fs.rmdir(directory);
+        }
+        catch { /* keep non-empty directories */ }
+    }
+    if (removed.length > 0)
+        await writeTextSafely(manifestFile(paths), `${JSON.stringify({ skillFiles: manifest.skillFiles.filter((item) => !removed.includes(item)) }, null, 2)}\n`);
+    return removed;
+}
+export async function removeAddedSkillFiles(destination, relativeFiles) {
+    for (const relative of relativeFiles)
+        await fs.rm(path.join(destination, relative), { force: true });
+}