@wonseok-han/confluence-sync 1.8.0 → 2.0.0

package/dist/web/sync.js

@@ -1,66 +1,95 @@
+import { validateRestorePaths } from '../sync/pull.js';
+import { observeChanges } from '../sync/changes.js';
+import { documentDiff } from '../sync/diff.js';
+import { inspectStaging, changeStaging, stagedPaths, loadIndex } from '../sync/staging.js';
+import { connectionKeys, importConnection, mergeConnection } from '../confluence/env-file.js';
+import { loadWorkspace, inScope, inNestedWorkspace, requireScope } from '../sync/workspace.js';
+import { mappingPath as defaultMappingPath, METADATA_DIR } from '../sync/metadata.js';
+import { connectWorkspace } from '../sync/scope.js';
 import { referenceRoots } from '../sync/references.js';
 /** Web adapter for the existing push CLI. Only preview and incremental push are exposed. */
-import { spawn } from 'node:child_process';
+import { runSyncCLI } from './node-runner.js';
+export { runSyncCLI };
+import { createReadStream } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
-import { readFile, readdir, realpath, stat, lstat } from 'node:fs/promises';
+import { readFile, readdir, realpath, stat, lstat, writeFile, rename, unlink } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { parse } from 'dotenv';
 import { within } from './output.js';
-import { collectMarkdown, resolveSelection } from '../documents/catalog.js';
+import { collectMarkdown } from '../documents/catalog.js';
 import { buildIgnorer } from '../sync/ignore.js';
-const keys = ['CONFLUENCE_BASE_URL', 'CONFLUENCE_EMAIL', 'CONFLUENCE_API_TOKEN', 'CONFLUENCE_SPACE_KEY', 'CONFLUENCE_PARENT_ID', 'CONFLUENCE_PARENT_PAGE_ID'];
-async function settings(base, envFile) {
-    let source = envFile ? resolve(envFile) : join(base, '.env');
-    let values;
+const keys = connectionKeys;
+function receiveFormat(input) {
+    const format = input?.format;
+    if (format !== undefined && format !== 'markdown' && format !== 'obsidian')
+        throw new Error('내부 링크 형식을 확인하세요. Markdown 또는 Obsidian을 선택하세요.');
+    return format ?? 'markdown';
+}
+async function settings(base, envId, imports) {
+    if (envId) {
+        const imported = imports.get(envId);
+        if (!imported)
+            throw new Error('가져온 .env 설정이 만료되었습니다. 파일을 다시 가져오세요.');
+        return { env: imported.env, source: imported.source };
+    }
+    const source = join(base, '.env');
+    let values = {};
     try {
-        source = await realpath(source);
         values = parse(await readFile(source));
     }
     catch (error) {
-        if (envFile || error.code !== 'ENOENT')
-            throw new Error('.env 파일을 읽을 수 없습니다. 경로와 권한을 확인해 주세요.');
-        source = '웹 서버 실행 환경 (.env / 환경변수)';
-        values = process.env;
+        if (error.code !== 'ENOENT')
+            throw new Error('기준 폴더의 .env 파일을 읽을 수 없습니다.');
     }
     const env = {};
     for (const key of keys)
         env[key] = values[key]?.trim() ?? '';
-    env.CONFLUENCE_PARENT_ID ||= env.CONFLUENCE_PARENT_PAGE_ID;
     return { env, source };
 }
-function publicConfig(env, source) {
+function publicConfig(env, source, workspace) {
     return { source, baseUrl: env.CONFLUENCE_BASE_URL, email: env.CONFLUENCE_EMAIL,
-        spaceKey: env.CONFLUENCE_SPACE_KEY, parentId: env.CONFLUENCE_PARENT_ID,
-        hasToken: !!env.CONFLUENCE_API_TOKEN,
+        spaceKey: env.CONFLUENCE_SPACE_KEY, connected: workspace?.version === 2 && !!workspace.remoteRoot && workspace.connection?.baseUrl.replace(/\/$/, '') === env.CONFLUENCE_BASE_URL?.replace(/\/$/, '') && workspace.connection?.spaceKey === env.CONFLUENCE_SPACE_KEY,
+        rootPath: workspace?.remoteRoot?.path ?? null, hasToken: !!env.CONFLUENCE_API_TOKEN,
         missing: keys.slice(0, 4).filter(key => !env[key]) };
 }
 // The preview is invalidated if documents, attachments, mapping, ignore rules or credentials change.
-async function fingerprint(base, env) {
+async function fingerprint(base, env, skipIndex = false) {
     const hash = createHash('sha256').update(JSON.stringify(env));
     const walk = async (dir) => {
         const entries = (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
         for (const entry of entries) {
-            if (entry.name === 'node_modules' || (entry.name.startsWith('.') && !['.confluence-sync.json', '.confluence-syncignore'].includes(entry.name)))
+            if (entry.name === 'node_modules' || (entry.name.startsWith('.') && ![METADATA_DIR, '.confluence-sync.json', '.confluence-syncignore', '.confluence-workspace.json'].includes(entry.name)))
                 continue;
             const path = join(dir, entry.name);
+            if (relative(base, path).split('\\').join('/') === `${METADATA_DIR}/remote.json` || skipIndex && relative(base, path).split('\\').join('/') === `${METADATA_DIR}/index.json`)
+                continue;
             if (entry.isDirectory())
                 await walk(path);
             else if (entry.isFile()) {
-                const info = await stat(path);
-                hash.update(JSON.stringify([relative(base, path), info.size, info.mtimeMs, info.ctimeMs]));
-                if (/\.md$/i.test(path) || entry.name.startsWith('.'))
-                    hash.update(await readFile(path));
+                if (skipIndex) {
+                    // Background local scans keep the lightweight metadata shortcut.
+                    const info = await stat(path);
+                    hash.update(JSON.stringify([relative(base, path), info.size, info.mtimeMs, info.ctimeMs]));
+                    if (/\.md$/i.test(path) || entry.name.startsWith('.') || relative(base, path).split(/[\\/]/).includes(METADATA_DIR))
+                        hash.update(await readFile(path));
+                }
+                else {
+                    // Approval follows bytes, not OneDrive hydration/timestamp changes.
+                    const content = createHash('sha256');
+                    for await (const chunk of createReadStream(path))
+                        content.update(chunk);
+                    hash.update(JSON.stringify([relative(base, path), content.digest('hex')]));
+                }
             }
         }
     };
     await walk(base);
     return hash.digest('hex');
 }
-async function prepare(input) {
+async function prepare(input, imports) {
     const body = input;
     if (!body || typeof body.base !== 'string' || typeof body.target !== 'string'
-        || typeof body.envFile !== 'string' || typeof body.verify !== 'boolean')
+        || typeof body.envId !== 'string' || typeof body.verify !== 'boolean')
         throw new Error('동기화 옵션을 확인해 주세요.');
     const base = await realpath(resolve(body.base));
     if (dirname(base) === base || !(await stat(base)).isDirectory())
@@ -71,13 +100,17 @@ async function prepare(input) {
     const target = body.target ? await realpath(resolve(body.target)) : base;
     if (!within(base, target))
         throw new Error('동기화 대상은 기준 폴더 안에 있어야 합니다.');
+    if (target !== base)
+        throw new Error('웹 Push는 기준 폴더 전체를 대상으로 합니다. 개별 파일은 csync push <파일>을 사용하세요.');
     const ignorer = buildIgnorer(base, []);
     const docs = collectMarkdown(base).map(path => relative(base, path).split('\\').join('/')).filter(path => !ignorer.ignores(path));
-    const picked = target === base ? docs : resolveSelection(docs, [target], base);
+    const workspace = loadWorkspace(base);
+    requireScope(workspace);
+    const picked = docs.filter(rel => inScope(rel, workspace) && !inNestedWorkspace(base, rel));
     if (!picked.length)
-        throw new Error('동기화할 Markdown 문서가 없습니다. 선택 범위와 .confluence-syncignore를 확인해 주세요.');
+        throw new Error('동기화할 Markdown 문서가 없습니다. 선택 범위와 .csync/ignore(또는 기존 제외 파일)를 확인해 주세요.');
     // A damaged mapping must not silently turn a whole document set into new pages.
-    const mappingPath = join(base, '.confluence-sync.json');
+    const mappingPath = defaultMappingPath(base);
     try {
         if (!(await lstat(mappingPath)).isFile())
             throw new Error('invalid mapping');
@@ -88,10 +121,11 @@ async function prepare(input) {
     }
     catch (error) {
         if (error.code !== 'ENOENT')
-            throw new Error('.confluence-sync.json 매핑 파일이 올바르지 않습니다. 기존 매핑을 확인해 주세요.');
+            throw new Error('페이지 매핑 파일이 올바르지 않습니다. .csync/mapping.json 또는 기존 매핑을 확인해 주세요.');
     }
-    const { env, source } = await settings(base, body.envFile);
-    const selection = { base, target: target === base ? '' : target, envFile: body.envFile, verify: body.verify, referenceRoots: refs };
+    stagedPaths(base);
+    const { env, source } = await settings(base, body.envId, imports);
+    const selection = { base, target: target === base ? '' : target, envId: body.envId, verify: body.verify, referenceRoots: refs };
     const snapshots = await Promise.all([base, ...refs].map(async (root) => {
         const config = await readFile(join(root, '.env'), 'utf8').catch(error => {
             if (error.code === 'ENOENT')
@@ -100,50 +134,51 @@ async function prepare(input) {
         });
         return [root, await fingerprint(root, env), createHash('sha256').update(config).digest('hex')];
     }));
-    return { selection, env, config: publicConfig(env, source), fingerprint: JSON.stringify(snapshots) };
+    return { selection, env, config: publicConfig(env, source, workspace), fingerprint: JSON.stringify(snapshots) };
 }
-export const runSyncCLI = (args, settings, log) => new Promise((resolveJob, reject) => {
-    const source = import.meta.url.endsWith('.ts');
-    const worker = fileURLToPath(new URL(source ? '../sync.ts' : '../sync.js', import.meta.url));
-    const child = spawn(process.execPath, [...(source ? process.execArgv : []), worker, ...args], {
-        env: { ...process.env, ...settings, NO_COLOR: '1' }, stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    // Emit complete lines so secret masking cannot be bypassed by split stream chunks.
-    for (const stream of [child.stdout, child.stderr]) {
-        let pending = '';
-        stream.setEncoding('utf8');
-        stream.on('data', (chunk) => {
-            pending += chunk;
-            const end = pending.lastIndexOf('\n');
-            if (end >= 0) {
-                log(pending.slice(0, end + 1));
-                pending = pending.slice(end + 1);
-            }
-        });
-        stream.on('end', () => { if (pending)
-            log(pending); });
-    }
-    child.once('error', reject);
-    child.once('close', code => resolveJob(code ?? 1));
-});
-export function createWebSync(runner = runSyncCLI) {
+export function createWebSync(runner = runSyncCLI, initialImports = []) {
+    const imports = new Map(initialImports);
     let job = null;
     let plan = null;
     let locked = false;
+    let restorePlan = null;
+    let stagingCache;
+    const connectionSettings = async (input) => {
+        const body = input;
+        if (!body || typeof body.base !== 'string' || typeof body.envId !== 'string')
+            throw new Error('설정 경로를 확인하세요.');
+        const base = await realpath(resolve(body.base));
+        if (!(await stat(base)).isDirectory() || dirname(base) === base)
+            throw new Error('로컬 기준 폴더를 선택하세요.');
+        const { env } = await settings(base, body.envId, imports);
+        const config = { baseUrl: env.CONFLUENCE_BASE_URL, email: env.CONFLUENCE_EMAIL, token: env.CONFLUENCE_API_TOKEN, spaceKey: env.CONFLUENCE_SPACE_KEY };
+        return { base, config, body };
+    };
     const running = () => locked || job?.state === 'running';
     const launch = (kind, prepared) => {
         const current = { id: randomUUID(), kind, state: 'running', log: '', selection: prepared.selection, config: prepared.config, planId: null, startedAt: new Date().toISOString() };
         job = current;
         plan = null;
         const { base, target, verify } = prepared.selection;
-        const args = ['--base', base];
-        for (const root of prepared.selection.referenceRoots)
+        const args = [kind === 'pull' ? 'pull' : kind === 'fetch' ? 'fetch' : kind === 'restore' ? 'restore' : 'push', '--base', base];
+        for (const root of kind === 'pull' || kind === 'fetch' || kind === 'restore' ? [] : prepared.selection.referenceRoots)
             args.push('--reference-root', root);
-        if (target)
+        if (target && kind !== 'pull')
             args.push(target);
         if (kind === 'preview')
             args.push('--dry-run');
-        else if (verify)
+        if (kind === 'restore') {
+            args.push(...prepared.selection.restorePaths);
+            if (prepared.selection.restoreOverwrite)
+                args.push('--overwrite');
+        }
+        if (['pull', 'restore'].includes(kind) && prepared.selection.format === 'obsidian')
+            args.push('--obsidian');
+        if (kind === 'pull' && prepared.selection.full)
+            args.push('--full');
+        if (kind === 'pull' && prepared.selection.remoteOnly)
+            args.push('--remote-only');
+        if (verify && kind !== 'pull')
             args.push('--verify');
         let reportedFailure = false;
         const secrets = [prepared.env.CONFLUENCE_API_TOKEN, Buffer.from(`${prepared.env.CONFLUENCE_EMAIL}:${prepared.env.CONFLUENCE_API_TOKEN}`).toString('base64')].filter(Boolean);
@@ -161,12 +196,30 @@ export function createWebSync(runner = runSyncCLI) {
                 if (!succeeded)
                     log('\n일부 작업이 실패했을 수 있습니다. 위 내역을 확인하고 다시 미리보기해 주세요.\n');
                 if (kind === 'preview' && succeeded) {
-                    const updated = await prepare(prepared.selection);
+                    const updated = await prepare(prepared.selection, imports);
                     if (updated.fingerprint !== prepared.fingerprint)
                         throw new Error('미리보기 중 문서나 설정이 바뀌었습니다. 다시 미리보기해 주세요.');
                     plan = { id: randomUUID(), prepared };
                     current.planId = plan.id;
                 }
+                if (succeeded && ['push', 'pull'].includes(kind)) {
+                    current.phase = 'fetch';
+                    log('\n[자동 Fetch] 최신 원격 상태를 다시 확인합니다.\n');
+                    reportedFailure = false;
+                    try {
+                        const refreshCode = await runner(['fetch', '--base', base, '--refresh'], prepared.env, log);
+                        if (refreshCode !== 0 || reportedFailure)
+                            throw new Error('후속 Fetch가 완료되지 않았습니다.');
+                    }
+                    catch (error) {
+                        current.refreshFailed = true;
+                        log(`[후속 Fetch 실패] ${error instanceof Error ? error.message : String(error)} 이미 완료된 ${kind === 'push' ? '업로드' : '가져오기'}는 유지됩니다. Fetch를 다시 실행하세요.\n`);
+                    }
+                    finally {
+                        delete current.phase;
+                    }
+                }
+                current.warningCount = Number(current.log.match(/(?:^|\n)\[경고 요약\] 원격 첨부 (\d+)개/)?.[1] ?? 0);
                 current.state = succeeded ? 'succeeded' : 'failed';
             }
             catch (error) {
@@ -180,20 +233,261 @@ export function createWebSync(runner = runSyncCLI) {
         return current;
     };
     return {
+        connectionImports: () => [...imports],
         running,
+        diff: async (input) => {
+            if (running())
+                throw new Error('다른 작업이 진행 중입니다.');
+            locked = true;
+            try {
+                const { base, config } = await connectionSettings(input);
+                const body = input;
+                if (typeof body.path !== 'string' || body.remote !== undefined && typeof body.remote !== 'boolean')
+                    throw new Error('비교할 문서를 선택하세요.');
+                return await documentDiff(base, body.path, { remote: body.remote, env: config });
+            }
+            finally {
+                locked = false;
+            }
+        },
+        staging: async (input) => {
+            if (running())
+                throw new Error('다른 작업이 진행 중입니다.');
+            locked = true;
+            try {
+                const { base, config } = await connectionSettings(input);
+                const body = input;
+                if (body.remoteOnly !== undefined && typeof body.remoteOnly !== 'boolean')
+                    throw new Error('원격 목록 조회 옵션을 확인하세요.');
+                if (body.remoteOnly) {
+                    if (body.action !== undefined)
+                        throw new Error('원격 목록 조회에서는 업로드 선택을 변경할 수 없습니다.');
+                    const view = observeChanges(base, [], config);
+                    const rows = view.rows.filter(row => row.remoteState && row.remoteState !== 'unchanged').map(row => ({ ...row, localUnverified: !(row.remoteState === 'new' && row.status === 'unavailable') }));
+                    return { ...view, rows, revision: JSON.stringify([view.remoteCheckedAt, rows]) };
+                }
+                if (body.referenceRoots !== undefined && (!Array.isArray(body.referenceRoots) || body.referenceRoots.some(p => typeof p !== 'string')))
+                    throw new Error('참조 폴더를 확인하세요.');
+                const options = { referenceRoots: body.referenceRoots ?? [], baseUrl: config.baseUrl };
+                const cacheKey = JSON.stringify([base, options, loadWorkspace(base)]);
+                const revision = async () => JSON.stringify(await Promise.all([base, ...referenceRoots(base, options.referenceRoots)].map(root => fingerprint(root, { connection: JSON.stringify(config) }, true))));
+                let currentRevision = await revision();
+                let rows;
+                const cacheMatched = stagingCache?.key === cacheKey && stagingCache.revision === currentRevision;
+                if (body.action !== undefined) {
+                    if (!['add', 'remove'].includes(String(body.action)) || !Array.isArray(body.paths) || body.paths.some(p => typeof p !== 'string'))
+                        throw new Error('문서 선택을 확인하세요.');
+                    plan = null;
+                    const touched = await changeStaging(base, body.paths, body.action, options);
+                    const prior = stagingCache?.key === cacheKey ? stagingCache.rows : [];
+                    const merged = new Map(prior.map(row => [row.path, row]));
+                    if (body.action === 'add')
+                        for (const row of touched)
+                            merged.set(row.path, { ...row, pageId: row.pageId, staged: true, stale: false });
+                    const entries = loadIndex(base).entries;
+                    rows = [...merged.values()].map(row => ({ ...row, staged: !!entries[row.path], stale: !!entries[row.path] && (!!row.unmapped || JSON.stringify(entries[row.path]) !== JSON.stringify(row.entry)) }));
+                    if (!cacheMatched)
+                        currentRevision = '';
+                }
+                else
+                    rows = stagingCache?.key === cacheKey && stagingCache.revision === currentRevision ? stagingCache.rows : await inspectStaging(base, options);
+                const activeEntries = loadIndex(base).entries;
+                rows = rows.map(row => ({ ...row, staged: !!activeEntries[row.path], stale: !!activeEntries[row.path] && (!!row.unmapped || JSON.stringify(activeEntries[row.path]) !== JSON.stringify(row.entry)) }));
+                for (const [path, entry] of Object.entries(activeEntries))
+                    if (!rows.some(row => row.path === path))
+                        rows.push({ path, status: 'unavailable', staged: true, stale: true, entry });
+                stagingCache = { key: cacheKey, rows, revision: currentRevision };
+                const view = observeChanges(base, rows, config);
+                return { ...view, revision: JSON.stringify([currentRevision, activeEntries, view.remoteCheckedAt, view.rows]) };
+            }
+            finally {
+                locked = false;
+            }
+        },
+        importEnv: async (input) => {
+            if (running())
+                throw new Error('다른 Confluence 작업이 진행 중입니다.');
+            const body = input;
+            if (!body || typeof body.base !== 'string' || typeof body.text !== 'string' || typeof body.name !== 'string' || body.name.length > 255)
+                throw new Error('.env 파일을 선택해 주세요.');
+            const base = await realpath(resolve(body.base));
+            if (!(await stat(base)).isDirectory() || dirname(base) === base)
+                throw new Error('로컬 기준 폴더를 선택하세요.');
+            const imported = { ...importConnection(body.text), source: `가져온 파일 · ${body.name}` };
+            const envId = randomUUID();
+            imports.set(envId, imported);
+            plan = null;
+            if (imports.size > 20)
+                imports.delete(imports.keys().next().value);
+            return { envId, config: publicConfig(imported.env, imported.source, loadWorkspace(base)) };
+        },
+        saveEnv: async (input) => {
+            if (running())
+                throw new Error('다른 Confluence 작업이 진행 중입니다.');
+            locked = true;
+            let temp;
+            try {
+                const body = input;
+                if (!body || typeof body.base !== 'string' || typeof body.envId !== 'string')
+                    throw new Error('가져온 .env 설정을 확인하세요.');
+                const imported = imports.get(body.envId);
+                if (!imported || keys.some(key => !imported.env[key]))
+                    throw new Error('필수 연결 설정을 모두 포함한 .env를 가져오세요.');
+                const base = await realpath(resolve(body.base));
+                if (!(await stat(base)).isDirectory() || dirname(base) === base)
+                    throw new Error('로컬 기준 폴더를 선택하세요.');
+                const path = join(base, '.env');
+                const snapshot = async () => {
+                    try {
+                        if (!(await lstat(path)).isFile())
+                            throw new Error('.env는 일반 파일이어야 합니다. 심볼릭 링크는 저장할 수 없습니다.');
+                        const content = await readFile(path, 'utf8');
+                        return { content, hash: createHash('sha256').update(content).digest('hex') };
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT')
+                            return { content: '', hash: null };
+                        throw error;
+                    }
+                };
+                const before = await snapshot();
+                if (!Object.hasOwn(body, 'expectedHash'))
+                    return { needsConfirmation: before.hash !== null, expectedHash: before.hash, path };
+                if (body.expectedHash !== before.hash)
+                    throw new Error('.env가 변경되었습니다. 저장을 다시 시도해 주세요.');
+                temp = join(base, `.csync-env-${randomUUID()}.tmp`);
+                await writeFile(temp, mergeConnection(before.content, imported.content), { mode: 0o600, flag: 'wx' });
+                if ((await snapshot()).hash !== before.hash)
+                    throw new Error('.env가 변경되었습니다. 저장을 다시 시도해 주세요.');
+                await rename(temp, path);
+                temp = undefined;
+                plan = null;
+                const { env, source } = await settings(base, '', imports);
+                return { saved: true, config: publicConfig(env, source, loadWorkspace(base)) };
+            }
+            finally {
+                if (temp)
+                    await unlink(temp).catch(() => { });
+                locked = false;
+            }
+        },
+        connect: async (input) => {
+            if (running())
+                throw new Error('다른 Confluence 작업이 진행 중입니다.');
+            locked = true;
+            plan = null;
+            try {
+                const { base, config, body } = await connectionSettings(input);
+                await connectWorkspace(base, config);
+                const { env, source } = await settings(base, body.envId, imports);
+                return publicConfig(env, source, loadWorkspace(base));
+            }
+            finally {
+                locked = false;
+            }
+        },
         current: () => job,
-        config: async (base, envFile) => {
+        config: async (base, envId) => {
             const resolved = await realpath(resolve(base));
-            const { env, source } = await settings(resolved, envFile);
-            return publicConfig(env, source);
+            const { env, source } = await settings(resolved, envId, imports);
+            return publicConfig(env, source, loadWorkspace(resolved));
+        },
+        fetch: async (input) => {
+            if (running())
+                throw new Error('다른 작업이 진행 중입니다.');
+            locked = true;
+            plan = null;
+            try {
+                const { base, config, body } = await connectionSettings(input);
+                const workspace = loadWorkspace(base);
+                requireScope(workspace);
+                const { env, source } = await settings(base, body.envId, imports);
+                const visible = publicConfig(env, source, workspace);
+                if (visible.missing.length)
+                    throw new Error(`설정 누락: ${visible.missing.join(', ')}`);
+                const url = new URL(config.baseUrl);
+                if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash)
+                    throw new Error('Confluence BASE_URL은 인증정보·쿼리가 없는 HTTPS 주소여야 합니다.');
+                return launch('fetch', { selection: { base, target: '', envId: body.envId, verify: false, referenceRoots: [] }, env, config: visible, fingerprint: '' });
+            }
+            finally {
+                locked = false;
+            }
+        },
+        restore: async (input) => {
+            if (running())
+                throw new Error('다른 작업이 진행 중입니다.');
+            locked = true;
+            try {
+                const { base, body } = await connectionSettings(input);
+                const request = input;
+                const format = receiveFormat(input);
+                const workspace = loadWorkspace(base);
+                requireScope(workspace);
+                const { env, source } = await settings(base, body.envId, imports);
+                const config = publicConfig(env, source, workspace);
+                if (!config.connected || config.missing.length)
+                    throw new Error('스페이스 연결과 .env 설정을 확인하세요.');
+                const url = new URL(config.baseUrl);
+                if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash)
+                    throw new Error('Confluence BASE_URL은 인증정보·쿼리가 없는 HTTPS 주소여야 합니다.');
+                if (request.confirmationId !== undefined) {
+                    const approved = restorePlan;
+                    restorePlan = null;
+                    if (!approved || request.confirmationId !== approved.id || approved.prepared.selection.base !== base || approved.prepared.selection.envId !== body.envId || approved.prepared.selection.format !== format)
+                        throw new Error('복구 대상을 다시 확인하세요.');
+                    if (await fingerprint(base, env) !== approved.prepared.fingerprint)
+                        throw new Error('확인 이후 로컬 문서나 설정이 바뀌었습니다. 복구 대상을 다시 확인하세요.');
+                    validateRestorePaths(base, approved.prepared.selection.restorePaths, approved.prepared.selection.restoreOverwrite);
+                    return { job: launch('restore', approved.prepared) };
+                }
+                if (typeof request.path !== 'string' || typeof request.overwrite !== 'boolean')
+                    throw new Error('복구할 문서와 덮어쓰기 여부를 확인하세요.');
+                const paths = validateRestorePaths(base, [request.path], request.overwrite);
+                const id = randomUUID();
+                restorePlan = { id, prepared: { selection: { base, target: '', envId: body.envId, verify: false, referenceRoots: [], format, restorePaths: paths, restoreOverwrite: request.overwrite }, env, config, fingerprint: await fingerprint(base, env) } };
+                return { confirmationId: id, path: paths[0], overwrite: request.overwrite, format };
+            }
+            finally {
+                locked = false;
+            }
+        },
+        pull: async (input) => {
+            if (running())
+                throw new Error('다른 작업이 진행 중입니다.');
+            locked = true;
+            plan = null;
+            try {
+                const { base, config, body } = await connectionSettings(input);
+                const format = receiveFormat(input);
+                const full = body.full;
+                const remoteOnly = body.remoteOnly;
+                if (remoteOnly !== undefined && typeof remoteOnly !== 'boolean' || remoteOnly && full)
+                    throw new Error('원격 변경 가져오기 옵션을 확인하세요.');
+                if (full !== undefined && typeof full !== 'boolean')
+                    throw new Error('전체 탐색 설정을 확인하세요.');
+                const workspace = loadWorkspace(base);
+                requireScope(workspace);
+                const { env, source } = await settings(base, body.envId, imports);
+                const visible = publicConfig(env, source, workspace);
+                if (visible.missing.length)
+                    throw new Error(`설정 누락: ${visible.missing.join(', ')}`);
+                const url = new URL(config.baseUrl);
+                if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash)
+                    throw new Error('Confluence BASE_URL은 인증정보·쿼리가 없는 HTTPS 주소여야 합니다.');
+                return launch('pull', { selection: { base, target: '', envId: body.envId, verify: false, referenceRoots: [], format, ...(full ? { full: true } : {}), ...(remoteOnly ? { remoteOnly: true } : {}) }, env, config: visible, fingerprint: '' });
+            }
+            finally {
+                locked = false;
+            }
         },
         preview: async (input) => {
             if (running())
-                throw new Error('동기화 작업이 진행 중입니다.');
+                throw new Error('다른 Confluence 작업이 진행 중입니다.');
             locked = true;
             plan = null;
             try {
-                return launch('preview', await prepare(input));
+                return launch('preview', await prepare(input, imports));
             }
             finally {
                 locked = false;
@@ -201,14 +495,14 @@ export function createWebSync(runner = runSyncCLI) {
         },
         push: async (id) => {
             if (running())
-                throw new Error('동기화 작업이 진행 중입니다.');
+                throw new Error('다른 Confluence 작업이 진행 중입니다.');
             if (typeof id !== 'string' || !plan || plan.id !== id)
-                throw new Error('먼저 동기화 대상을 미리보기해 주세요.');
+                throw new Error('먼저 업로드 대상을 미리보기해 주세요.');
             locked = true;
             const approved = plan;
             plan = null;
             try {
-                const updated = await prepare(approved.prepared.selection);
+                const updated = await prepare(approved.prepared.selection, imports);
                 if (updated.fingerprint !== approved.prepared.fingerprint)
                     throw new Error('문서나 설정이 변경되었습니다. 다시 미리보기해 주세요.');
                 if (updated.config.missing.length)

package/dist/web/table-editor-script.js

@@ -0,0 +1,99 @@
+/** Trusted bridge runs in an opaque-origin sandbox; document scripts are removed first. */
+export function tableEditorBridge() {
+    const channel = document.currentScript.getAttribute('data-channel');
+    let enabled = false, selected = null, index = -1, widths = [];
+    let handles = [];
+    const send = (type) => parent.postMessage({ type, channel, index, widths }, '*');
+    const clear = () => { handles.forEach(h => h.remove()); handles = []; selected?.classList.remove('csync-selected'); };
+    const place = () => {
+        if (!selected)
+            return;
+        const rect = selected.getBoundingClientRect();
+        const total = widths.reduce((a, b) => a + b, 0);
+        let left = rect.left + scrollX;
+        handles.forEach((h, i) => {
+            left += widths[i] / total * rect.width;
+            Object.assign(h.style, { left: (left - 5) + 'px', top: (rect.top + scrollY) + 'px', height: rect.height + 'px' });
+        });
+    };
+    const apply = () => {
+        if (!selected)
+            return;
+        for (const group of Array.from(selected.children).filter(el => el.tagName === 'COLGROUP'))
+            group.remove();
+        const group = document.createElement('colgroup');
+        widths.forEach(width => { const col = document.createElement('col'); col.style.width = width + 'px'; group.append(col); });
+        selected.prepend(group);
+        selected.style.width = widths.reduce((a, b) => a + b, 0) + 'px';
+        selected.style.tableLayout = 'fixed';
+        place();
+    };
+    const select = (table, next, values) => {
+        clear();
+        selected = table;
+        index = next;
+        widths = values.slice();
+        selected.classList.add('csync-selected');
+        widths.slice(1).forEach((_, i) => {
+            const h = document.createElement('div');
+            h.className = 'csync-resize';
+            h.title = '열 너비 조절';
+            h.onpointerdown = event => {
+                event.preventDefault();
+                const start = event.clientX, original = widths.slice();
+                const scale = original.reduce((a, b) => a + b, 0) / selected.getBoundingClientRect().width;
+                h.setPointerCapture(event.pointerId);
+                h.onpointermove = move => {
+                    const delta = Math.round((move.clientX - start) * scale);
+                    const change = Math.max(40 - original[i], Math.min(original[i + 1] - 40, delta));
+                    widths[i] = original[i] + change;
+                    widths[i + 1] = original[i + 1] - change;
+                    apply();
+                    send('csync-table-change');
+                };
+                const end = () => { h.onpointermove = null; h.onpointerup = null; h.onpointercancel = null; };
+                h.onpointerup = end;
+                h.onpointercancel = end;
+            };
+            document.body.append(h);
+            handles.push(h);
+        });
+        apply();
+    };
+    document.addEventListener('click', event => {
+        if (!enabled || !(event.target instanceof Element))
+            return;
+        const table = event.target.closest('table[data-csync-table]');
+        if (!table)
+            return;
+        index = Number(table.dataset.csyncTable);
+        send('csync-table-select');
+    });
+    window.addEventListener('message', event => {
+        if (event.source !== parent || event.data?.channel !== channel)
+            return;
+        const data = event.data;
+        if (data.type === 'csync-table-edit') {
+            enabled = data.enabled === true;
+            document.body.classList.toggle('csync-editing', enabled);
+            if (!enabled) {
+                clear();
+                selected = null;
+            }
+        }
+        if (data.type === 'csync-table-widths' && enabled && Number.isInteger(data.index)
+            && Array.isArray(data.widths) && data.widths.length <= 32 && data.widths.every((w) => typeof w === 'number' && Number.isInteger(w) && w >= 40 && w <= 3000)) {
+            const table = document.querySelector(`table[data-csync-table="${data.index}"]`);
+            if (!table)
+                return;
+            if (table === selected) {
+                widths = data.widths.slice();
+                apply();
+            }
+            else
+                select(table, data.index, data.widths);
+        }
+    });
+    window.addEventListener('resize', place);
+    window.addEventListener('scroll', place);
+}