@wonseok-han/confluence-sync 1.8.0 → 2.0.0

package/dist/web/document-source.js

@@ -0,0 +1,14 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { relative } from 'node:path';
+import { within } from './output.js';
+export const hiddenDocumentPath = (base, path) => relative(base, path).split(/[\\/]/).some(p => p.startsWith('.') || p === 'node_modules');
+export async function readPreviewSource(basePath, filePath) {
+    const base = await realpath(basePath);
+    const path = await realpath(filePath);
+    if (!(await stat(base)).isDirectory() || !within(base, path) || hiddenDocumentPath(base, path)
+        || !/\.md$/i.test(path) || !(await stat(path)).isFile())
+        throw new Error('선택한 폴더 안의 Markdown 파일을 선택해 주세요.');
+    if ((await stat(path)).size > 1_000_000)
+        throw new Error('문서 미리보기는 1MB 이하 파일을 지원합니다.');
+    return { source: await readFile(path, 'utf8'), base, path };
+}

package/dist/web/hosted-files.js

@@ -0,0 +1,189 @@
+/** Private workspace storage for browser sessions. Paths are virtual at the HTTP boundary. */
+import { readdir, lstat, readFile, mkdir, rename, rm } from 'node:fs/promises';
+import { resolve, join, dirname, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+import MarkdownIt from 'markdown-it';
+import { createDocument } from '@mixmark-io/domino';
+import { parse } from 'dotenv';
+import { mapMarkdownText } from '../conversion/pdf-pages.js';
+import { WIKILINK_RE, parseWikilink } from '../documents/anchors.js';
+import { within } from '../sync/workspace.js';
+import { isConfluenceWebPath } from '../confluence/links.js';
+export const MAX_FILE = 100 * 1024 * 1024, MAX_TOTAL = 512 * 1024 * 1024, MAX_FILES = 20000;
+export const digest = (data) => createHash('sha256').update(data).digest('hex');
+export function safeRelative(path) {
+    if (!path || path.includes('\\') || /[\x00-\x1f:]/.test(path) || path.startsWith('/') || path.split('/').some(p => !p || p === '.' || p === '..'))
+        throw Error('잘못된 파일 경로입니다.');
+    return path;
+}
+export function permitted(path) {
+    const parts = path.split('/');
+    return !parts.some((part, i) => part === 'node_modules' || part === '.git' || (part.startsWith('.') && !(i === 0 && ['.csync', '.env', '.confluence-sync.json', '.confluence-workspace.json', '.confluence-syncignore'].includes(part))));
+}
+export function pathIn(mounts, path) {
+    const mount = mounts.find(m => path === m.virtual || path.startsWith(m.virtual + '/'));
+    if (!mount)
+        throw Error('선택한 브라우저 폴더 안의 경로만 사용할 수 있습니다.');
+    const rel = path.slice(mount.virtual.length).replace(/^\//, '');
+    if (rel)
+        safeRelative(rel);
+    return join(mount.root, rel);
+}
+export function virtualPath(mounts, path) {
+    for (const mount of mounts) {
+        const rel = relative(mount.root, path);
+        if (!rel)
+            return mount.virtual;
+        if (within(mount.root, path))
+            return mount.virtual + '/' + rel.split('\\').join('/');
+    }
+    throw Error('작업공간 밖의 경로입니다.');
+}
+export async function snapshot(mounts, cache = new Map()) {
+    const files = [];
+    let total = 0;
+    async function walk(mount, dir) {
+        for (const entry of await readdir(dir, { withFileTypes: true })) {
+            const file = join(dir, entry.name), rel = relative(mount.root, file).split('\\').join('/');
+            if (!permitted(rel))
+                continue;
+            safeRelative(rel);
+            const stat = await lstat(file);
+            if (stat.isSymbolicLink())
+                throw Error('작업공간의 심볼릭 링크는 지원하지 않습니다.');
+            if (stat.isDirectory()) {
+                await walk(mount, file);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            total += stat.size;
+            if (files.length >= MAX_FILES || stat.size > MAX_FILE || total > MAX_TOTAL)
+                throw Error('작업공간 한도를 초과했습니다(파일 100MiB, 전체 512MiB, 20,000개).');
+            const stamp = `${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`, old = cache.get(file), hash = old?.stamp === stamp ? old.hash : digest(await readFile(file));
+            cache.set(file, { stamp, hash });
+            files.push({ path: virtualPath(mounts, file), size: stat.size, hash });
+        }
+    }
+    for (const mount of mounts)
+        await walk(mount, mount.root);
+    return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+export function validateEnv(text) { const env = parse(text); const base = env.CONFLUENCE_BASE_URL; if (!base)
+    return; const url = new URL(base); if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash || !(url.hostname === 'api.atlassian.com' || url.hostname.endsWith('.atlassian.net')))
+    throw Error('배포 웹은 Atlassian Cloud의 HTTPS 주소만 지원합니다.'); }
+/** Reject local link destinations that would make shared CLI code read server files.
+ * Metadata-only Fetch does not follow document links; keep env/mapping checks.
+ */
+export async function validateWorkspace(mounts, checkEnv = true, checkDocuments = true) {
+    const parser = new MarkdownIt({ html: true });
+    const entries = await snapshot(mounts);
+    const allowed = (file, target, webLink = false) => {
+        try {
+            target = target.replace(/^<(.*)>$/, '$1');
+            for (let i = 0; i < 4; i++) {
+                const decoded = decodeURIComponent(target);
+                if (decoded === target)
+                    break;
+                target = decoded;
+            }
+        }
+        catch {
+            throw Error('해석할 수 없는 링크 경로입니다.');
+        }
+        if (!target || target.startsWith('#') || /^(?:https?:|mailto:|data:)/i.test(target))
+            return;
+        if (webLink && isConfluenceWebPath(target))
+            return;
+        if (/^[a-z][a-z\d+.-]*:|^\/\//i.test(target) || target.startsWith('/') || target.includes('\\'))
+            throw Error(`${virtualPath(mounts, file)}: 서버의 절대 경로를 참조하는 문서는 처리할 수 없습니다.`);
+        const path = resolve(dirname(file), target.split(/[?#]/)[0]);
+        if (!mounts.some(m => within(m.root, path)))
+            throw Error('선택한 폴더 밖의 첨부·문서를 참조합니다. 참조 폴더를 추가하거나 링크를 수정하세요.');
+    };
+    for (const entry of entries) {
+        const file = pathIn(mounts, entry.path), rel = relative(mounts.find(m => entry.path.startsWith(m.virtual + '/')).root, file).split('\\').join('/');
+        if (rel === '.env') {
+            if (checkEnv)
+                validateEnv(await readFile(file, 'utf8'));
+            continue;
+        }
+        if (rel === '.csync/mapping.json' || rel === '.confluence-sync.json' || rel === '.csync/index.json') {
+            const value = JSON.parse(await readFile(file, 'utf8'));
+            for (const key of Object.keys(rel.endsWith('index.json') ? value.entries ?? {} : value))
+                safeRelative(key.replace(/\/$/, ''));
+        }
+        if (!checkDocuments || !/\.md$/i.test(file) || rel.startsWith('.csync/'))
+            continue;
+        const text = await readFile(file, 'utf8');
+        const scan = (part) => {
+            for (const match of part.matchAll(/(?<!!)(!?)\[([^\]\n]*)\]\((<[^>\n]+>|[^()\s]+)\)/g)) {
+                if ((part.slice(0, match.index).match(/\\+$/)?.[0].length ?? 0) % 2)
+                    continue;
+                allowed(file, match[3], !match[1]);
+            }
+            for (const match of part.matchAll(WIKILINK_RE)) {
+                if ((part.slice(0, match.index).match(/\\+$/)?.[0].length ?? 0) % 2)
+                    continue;
+                const link = parseWikilink(match[1], match[2], match[3], match[4]);
+                if (link?.target)
+                    allowed(file, link.target, !link.embed);
+            }
+            return part;
+        };
+        mapMarkdownText(text, scan, html => scan(html.replace(/<!--[\s\S]*?-->|<(script|style|pre|code)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, '')));
+        const inspect = (tokens) => {
+            for (const token of tokens) {
+                if (token.type === 'image')
+                    allowed(file, token.attrGet('src') ?? '');
+                if (token.type === 'link_open')
+                    allowed(file, token.attrGet('href') ?? '', true);
+                if (token.children)
+                    inspect(token.children);
+                if (token.type === 'html_block' || token.type === 'html_inline')
+                    for (const node of Array.from(createDocument(token.content).querySelectorAll('[href], [src]'))) {
+                        if (node.hasAttribute('href'))
+                            allowed(file, node.getAttribute('href') ?? '', node.localName === 'a');
+                        if (node.hasAttribute('src'))
+                            allowed(file, node.getAttribute('src') ?? '');
+                    }
+            }
+        };
+        inspect(parser.parse(text, {}));
+    }
+}
+/** Apply a complete upload transaction; rollback only files this transaction moved. */
+export async function commitMirror(mounts, stage, uploads, removed) {
+    const applied = [], backups = [];
+    await mkdir(join(stage, 'backup'), { recursive: true });
+    try {
+        for (const path of [...uploads.map(f => f.path), ...removed]) {
+            const file = pathIn(mounts, path);
+            try {
+                const stat = await lstat(file);
+                if (!stat.isFile() || stat.isSymbolicLink())
+                    throw Error('파일 충돌을 확인하세요.');
+                const backup = join(stage, 'backup', String(backups.length));
+                await rename(file, backup);
+                backups.push({ file, backup });
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
+        for (let i = 0; i < uploads.length; i++) {
+            const file = pathIn(mounts, uploads[i].path);
+            await mkdir(dirname(file), { recursive: true });
+            await rename(join(stage, String(i)), file);
+            applied.push(file);
+        }
+    }
+    catch (error) {
+        for (const file of applied.reverse())
+            await rm(file, { force: true });
+        for (const item of backups.reverse())
+            await rename(item.backup, item.file);
+        throw error;
+    }
+}

package/dist/web/hosted.js

@@ -0,0 +1,316 @@
+/** Browser-only deployment: same CLI core inside isolated, short-lived file workspaces. */
+import { createServer } from 'node:http';
+import { randomBytes, randomUUID, createHash } from 'node:crypto';
+import { mkdtemp, mkdir, rm, readFile, writeFile, realpath } from 'node:fs/promises';
+import { join, resolve, extname, isAbsolute } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { startWeb, deployedUi } from './server.js';
+import { webPage } from './views/workspace.js';
+import { tableEditorBridge } from './table-editor-script.js';
+import { readPkgVersion } from '../shared/version.js';
+import { within } from '../sync/workspace.js';
+import { snapshot, pathIn, virtualPath, permitted, safeRelative, digest, validateWorkspace, validateEnv, commitMirror, MAX_FILE, MAX_TOTAL, MAX_FILES } from './hosted-files.js';
+function publicValue(session, value) {
+    if (typeof value === 'string') {
+        if (isAbsolute(value) && session.mounts.some(m => within(m.root, value)))
+            return virtualPath(session.mounts, value);
+        return session.mounts.reduce((text, m) => text.split(m.root).join(m.virtual), value).split(session.root).join('(임시 작업공간)');
+    }
+    if (Array.isArray(value))
+        return value.map(item => publicValue(session, item));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, publicValue(session, item)]));
+    return value;
+}
+const index = (files) => new Map(files.map(f => [f.path, f]));
+async function body(req, max = 16 * 1024 * 1024) { let size = 0; const chunks = []; for await (const chunk of req) {
+    size += chunk.length;
+    if (size > max)
+        throw Error('요청 크기 한도를 초과했습니다.');
+    chunks.push(Buffer.from(chunk));
+} return Buffer.concat(chunks); }
+const jsonBody = async (req) => { if (!req.headers['content-type']?.startsWith('application/json'))
+    throw Error('JSON 요청이 필요합니다.'); return JSON.parse((await body(req)).toString('utf8')); };
+export async function startHostedWeb(options = {}) {
+    const sessions = new Map();
+    let creating = 0;
+    const ttl = options.ttlMs ?? 30 * 60_000;
+    const publicOrigin = options.publicUrl ? deployedUi(options.publicUrl).origin : undefined;
+    const assets = resolve(fileURLToPath(new URL('../../dist/web/assets/', import.meta.url)));
+    const bridgeHash = createHash('sha256').update(`(${tableEditorBridge.toString()})()`).digest('base64');
+    const dispose = async (s) => { sessions.delete(s.id); s.core.server.closeAllConnections(); await new Promise(r => s.core.server.close(() => r())); await rm(s.root, { recursive: true, force: true }); };
+    const changes = async (s) => { const files = await snapshot(s.mounts, s.cache), old = index(s.baseline), now = index(files); return { files: files.filter(f => old.get(f.path)?.hash !== f.hash), removed: s.baseline.filter(f => !now.has(f.path)).map(f => f.path), snapshot: files }; };
+    const server = createServer(async (req, res) => {
+        const send = (code, value) => { res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(value)); };
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('Referrer-Policy', 'no-referrer');
+        res.setHeader('Content-Security-Policy', `default-src 'self'; script-src 'self' 'sha256-${bridgeHash}'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; frame-src 'self'; worker-src 'self'; font-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'`);
+        let session, locked = false;
+        try {
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            if (req.headers.origin && req.headers.origin !== (publicOrigin ?? `http://${req.headers.host}`)) {
+                send(403, { error: '같은 웹 화면에서만 요청할 수 있습니다.' });
+                return;
+            }
+            if (req.method === 'GET' && url.pathname === '/') {
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                res.end(webPage('browser', 'browser'));
+                return;
+            }
+            if (req.method === 'GET' && url.pathname === '/healthz') {
+                send(200, { ok: true });
+                return;
+            }
+            if (req.method === 'GET' && url.pathname.startsWith('/assets/')) {
+                const file = resolve(assets, decodeURIComponent(url.pathname.slice(8)));
+                if (file === assets || !within(assets, file))
+                    throw Error('잘못된 파일 경로입니다.');
+                const types = { '.js': 'text/javascript', '.css': 'text/css', '.ttf': 'font/ttf', '.png': 'image/png', '.svg': 'image/svg+xml', '.txt': 'text/plain; charset=utf-8' };
+                if (!types[extname(file)]) {
+                    send(404, {});
+                    return;
+                }
+                res.setHeader('Content-Type', types[extname(file)]);
+                res.end(await readFile(file));
+                return;
+            }
+            if (url.pathname === '/api/browser/session' && req.method === 'POST') {
+                const input = await jsonBody(req);
+                if (sessions.size + creating >= (options.maxSessions ?? 8)) {
+                    send(503, { error: '현재 작업공간이 가득 찼습니다. 잠시 후 다시 시도하세요.' });
+                    return;
+                }
+                const name = String(input.name ?? '문서');
+                if (!name || name.length > 255)
+                    throw Error('폴더 이름을 확인하세요.');
+                safeRelative(name);
+                if (name.includes('/'))
+                    throw Error('폴더 이름을 확인하세요.');
+                creating++;
+                let root;
+                try {
+                    root = await realpath(await mkdtemp(join(tmpdir(), 'csync-browser-')));
+                    await mkdir(join(root, 'workspace'));
+                    await mkdir(join(root, 'output'));
+                    const core = await startWeb({ start: join(root, 'workspace'), port: 0, syncRunner: options.syncRunner });
+                    const s = { id: randomUUID(), token: randomBytes(32).toString('hex'), root, core, mounts: [{ virtual: '/workspace/' + name, root: join(root, 'workspace') }, { virtual: '/output', root: join(root, 'output') }], baseline: [], cache: new Map(), busy: false, touched: Date.now() };
+                    sessions.set(s.id, s);
+                    send(201, { id: s.id, token: s.token, base: s.mounts[0].virtual, output: '/output', version: readPkgVersion() });
+                }
+                catch (e) {
+                    if (root)
+                        await rm(root, { recursive: true, force: true });
+                    throw e;
+                }
+                finally {
+                    creating--;
+                }
+                return;
+            }
+            const id = String(req.headers['x-csync-session'] ?? '');
+            session = sessions.get(id);
+            if (!session || req.headers['x-csync-token'] !== session.token) {
+                send(401, { error: '브라우저 작업공간을 다시 연결하세요.' });
+                return;
+            }
+            const s = session;
+            if (Date.now() - s.touched > ttl && !s.core.isRunning()) {
+                await dispose(s);
+                send(410, { error: '임시 작업공간이 만료되었습니다. 폴더를 다시 여세요.' });
+                return;
+            }
+            s.touched = Date.now();
+            if (s.busy) {
+                send(409, { error: '다른 브라우저 요청이 진행 중입니다.' });
+                return;
+            }
+            s.busy = true;
+            locked = true;
+            if (url.pathname === '/api/browser/session' && req.method === 'DELETE') {
+                if (s.core.isRunning())
+                    throw Error('작업 완료 후 연결을 해제하세요.');
+                await dispose(s);
+                send(200, { ok: true });
+                return;
+            }
+            if (url.pathname === '/api/browser/mount' && req.method === 'POST') {
+                if (s.core.isRunning())
+                    throw Error('작업 완료 후 폴더를 추가하세요.');
+                const input = await jsonBody(req);
+                if (input.kind !== 'reference')
+                    throw Error('폴더 종류를 확인하세요.');
+                const n = s.mounts.filter(m => m.readonly).length;
+                if (n >= 8)
+                    throw Error('참조 폴더는 8개까지 추가할 수 있습니다.');
+                const mount = { virtual: '/references/' + randomUUID(), root: join(s.root, 'reference-' + n), readonly: true };
+                await mkdir(mount.root);
+                s.mounts.push(mount);
+                send(201, { path: mount.virtual });
+                return;
+            }
+            if (url.pathname === '/api/browser/mirror' && req.method === 'POST') {
+                if (s.core.isRunning())
+                    throw Error('작업 중에는 파일을 다시 전송할 수 없습니다.');
+                const pending = await changes(s);
+                if (pending.files.length || pending.removed.length) {
+                    send(409, { error: '서버 결과를 로컬에 먼저 반영하세요.', code: 'APPLY_PENDING' });
+                    return;
+                }
+                const { files } = await jsonBody(req);
+                if (!Array.isArray(files) || files.length > MAX_FILES)
+                    throw Error('파일 목록 한도를 확인하세요.');
+                const seen = new Set();
+                let total = 0;
+                for (const f of files) {
+                    if (typeof f.path !== 'string' || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > MAX_FILE || typeof f.hash !== 'string' || !/^[a-f0-9]{64}$/.test(f.hash) || seen.has(f.path))
+                        throw Error('파일 목록을 확인하세요.');
+                    const file = pathIn(s.mounts, f.path);
+                    const mount = s.mounts.find(m => file !== m.root && within(m.root, file));
+                    if (!mount || !permitted(f.path.slice(mount.virtual.length + 1)))
+                        throw Error('지원하지 않는 파일 경로입니다.');
+                    seen.add(f.path);
+                    total += f.size;
+                }
+                if (total > MAX_TOTAL)
+                    throw Error('작업공간이 512MiB를 초과했습니다.');
+                if (s.transaction)
+                    await rm(s.transaction.stage, { recursive: true, force: true });
+                const before = index(s.baseline), uploads = files.filter(f => before.get(f.path)?.hash !== f.hash);
+                s.transaction = { stage: await mkdtemp(join(s.root, 'mirror-')), manifest: files, uploads, received: new Set() };
+                send(200, { uploads });
+                return;
+            }
+            if (url.pathname === '/api/browser/file' && req.method === 'PUT') {
+                const tx = s.transaction, path = url.searchParams.get('path') ?? '', at = tx?.uploads.findIndex(f => f.path === path) ?? -1;
+                if (!tx || at < 0)
+                    throw Error('파일 전송을 다시 시작하세요.');
+                const bytes = await body(req, MAX_FILE), file = tx.uploads[at];
+                if (bytes.length !== file.size || digest(bytes) !== file.hash)
+                    throw Error('파일 전송 중 내용이 바뀌었습니다. 다시 시도하세요.');
+                await writeFile(join(tx.stage, String(at)), bytes);
+                tx.received.add(path);
+                send(200, { ok: true });
+                return;
+            }
+            if (url.pathname === '/api/browser/commit' && req.method === 'POST') {
+                const tx = s.transaction;
+                if (!tx || tx.received.size !== tx.uploads.length)
+                    throw Error('파일 전송을 먼저 완료하세요.');
+                const remaining = new Set(tx.manifest.map(f => f.path));
+                await commitMirror(s.mounts, tx.stage, tx.uploads, s.baseline.filter(f => !remaining.has(f.path)).map(f => f.path));
+                s.baseline = await snapshot(s.mounts, s.cache);
+                await rm(tx.stage, { recursive: true, force: true });
+                s.transaction = undefined;
+                send(200, { ok: true });
+                return;
+            }
+            if (url.pathname === '/api/browser/changes' && req.method === 'GET') {
+                if (s.core.isRunning())
+                    throw Error('작업 완료 후 결과를 반영하세요.');
+                const value = await changes(s);
+                send(200, value);
+                return;
+            }
+            if (url.pathname === '/api/browser/file' && req.method === 'GET') {
+                const file = pathIn(s.mounts, url.searchParams.get('path') ?? '');
+                const bytes = await readFile(file);
+                if (bytes.length > MAX_FILE)
+                    throw Error('파일 크기를 확인하세요.');
+                res.setHeader('Content-Type', 'application/octet-stream');
+                res.end(bytes);
+                return;
+            }
+            if (url.pathname === '/api/browser/ack' && req.method === 'POST') {
+                const { files } = await jsonBody(req), now = await snapshot(s.mounts, s.cache);
+                if (JSON.stringify(files) !== JSON.stringify(now))
+                    throw Error('반영 중 서버 파일이 바뀌었습니다. 다시 확인하세요.');
+                s.baseline = now;
+                send(200, { ok: true });
+                return;
+            }
+            if (!url.pathname.startsWith('/api/') || !['GET', 'POST'].includes(req.method ?? '')) {
+                send(404, {});
+                return;
+            }
+            if (s.transaction)
+                throw Error('파일 전송을 먼저 완료하세요.');
+            if (url.pathname !== '/api/sync/job' && !s.core.isRunning()) {
+                const pending = await changes(s);
+                if (pending.files.length || pending.removed.length) {
+                    send(409, { error: '서버 결과를 로컬에 먼저 반영하세요.', code: 'APPLY_PENDING' });
+                    return;
+                }
+            }
+            if (['/api/pick-folder', '/api/open'].includes(url.pathname))
+                throw Error('브라우저에서 폴더를 선택하세요.');
+            if (req.method === 'POST') {
+                const input = await jsonBody(req);
+                if (url.pathname === '/api/sync/env/import')
+                    validateEnv(String(input.text ?? ''));
+                for (const key of ['base', 'file', 'out', 'start'])
+                    if (typeof input[key] === 'string') {
+                        if (!input[key] && ['base', 'file'].includes(key))
+                            throw Error('브라우저 폴더를 먼저 선택하세요.');
+                        if (input[key])
+                            input[key] = pathIn(s.mounts, input[key]);
+                    }
+                if (typeof input.path === 'string' && input.path.startsWith('/'))
+                    input.path = pathIn(s.mounts, input.path);
+                if (input.base && !within(s.mounts[0].root, input.base))
+                    throw Error('문서 폴더를 기준으로 작업하세요.');
+                if (input.referenceRoots)
+                    input.referenceRoots = input.referenceRoots.map((path) => pathIn(s.mounts, path));
+                if (url.pathname === '/api/convert' && !input.out) {
+                    input.out = s.mounts[1].root;
+                }
+                if (!['/api/sync/config'].includes(url.pathname))
+                    await validateWorkspace(s.mounts, url.pathname.startsWith('/api/sync/') && !input.envId && !url.pathname.endsWith('/env/import'), url.pathname !== '/api/sync/fetch' && !(url.pathname === '/api/sync/staging' && input?.remoteOnly === true));
+                const response = await fetch(s.core.url + url.pathname, { method: 'POST', headers: { 'X-Csync-Token': s.core.token, 'Content-Type': 'application/json' }, body: JSON.stringify(input) });
+                const data = await response.json();
+                send(response.status, publicValue(s, data));
+                return;
+            }
+            if (url.pathname === '/api/browse' || url.pathname === '/api/search')
+                url.searchParams.set('path', pathIn(s.mounts, url.searchParams.get('path') || s.mounts[0].virtual));
+            const response = await fetch(s.core.url + url.pathname + url.search, { headers: { 'X-Csync-Token': s.core.token } });
+            const data = await response.json();
+            if (url.pathname === '/api/browse') {
+                data.parent = data.path === s.mounts[0].root ? s.mounts[0].root : data.parent;
+                data.home = s.mounts[0].root;
+            }
+            send(response.status, publicValue(s, data));
+        }
+        catch (error) {
+            if (!res.writableEnded) {
+                const value = String(error.message);
+                send(400, { error: session ? value.split(session.root).join('(임시 작업공간)') : value });
+            }
+        }
+        finally {
+            if (locked && session)
+                session.busy = false;
+        }
+    });
+    const timer = setInterval(() => { for (const s of sessions.values())
+        if (!s.busy && !s.core.isRunning() && Date.now() - s.touched > ttl)
+            void dispose(s); }, Math.min(ttl, 60_000));
+    timer.unref();
+    await new Promise((done, reject) => { server.once('error', reject); server.listen(options.port ?? 8080, options.host ?? '0.0.0.0', done); });
+    return { server, url: `http://127.0.0.1:${server.address().port}`, close: async () => { clearInterval(timer); server.closeAllConnections(); await new Promise(r => server.close(() => r())); for (const s of [...sessions.values()])
+            await dispose(s); } };
+}
+export async function runHostedWeb(argv) {
+    const at = argv.indexOf('--port'), port = Number(at < 0 ? 8080 : argv[at + 1]);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw Error('포트를 확인하세요.');
+    const app = await startHostedWeb({ port, publicUrl: process.env.CSYNC_PUBLIC_URL || undefined });
+    console.log(`브라우저 작업공간 웹: 0.0.0.0:${port} (로컬 실행기 불필요)`);
+    const stop = () => void app.close();
+    process.once('SIGTERM', stop);
+    process.once('SIGINT', stop);
+    await new Promise(done => app.server.once('close', done));
+    process.removeListener('SIGTERM', stop);
+    process.removeListener('SIGINT', stop);
+}

package/dist/web/node-runner.js

@@ -0,0 +1,26 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+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));
+});

package/dist/web/preview.js

@@ -0,0 +1,74 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { dirname, extname, resolve } from 'node:path';
+import { createDocument } from '@mixmark-io/domino';
+import { htmlTableMarkdown } from '../documents/html-tables.js';
+import { splitFrontmatter } from '../documents/obsidian.js';
+import { within } from './output.js';
+import { readPreviewSource, hiddenDocumentPath as hidden } from './document-source.js';
+import { editableTables, sourceHash } from './table-format.js';
+import { tableEditorBridge } from './table-editor-script.js';
+import { randomBytes } from 'node:crypto';
+const elements = new Set('h1 h2 h3 h4 h5 h6 p a img ul ol li dl dt dd blockquote pre code em strong s del b i u sub sup br hr table caption colgroup col thead tbody tfoot tr th td span div details summary'.split(' '));
+const discard = new Set('SCRIPT STYLE IFRAME OBJECT EMBED FORM INPUT BUTTON TEXTAREA SELECT META LINK BASE SVG MATH TEMPLATE'.split(' '));
+const attributes = new Set(['alt', 'title', 'colspan', 'rowspan', 'span', 'start', 'scope', 'id']);
+const imageTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.avif': 'image/avif' };
+const allowedStyle = /^(?:width|max-width|height|text-align|vertical-align|table-layout|color|background-color|white-space|font-weight|font-style|text-decoration)$/i;
+/** Return a self-contained, inert document. No file writes or external requests. */
+export async function previewDocument(basePath, filePath, nonce) {
+    const { source: original, base, path: file } = await readPreviewSource(basePath, filePath);
+    const { body } = splitFrontmatter(original);
+    const doc = createDocument(htmlTableMarkdown().render(body));
+    for (const element of Array.from(doc.body.querySelectorAll('*'))) {
+        if (discard.has(element.tagName)) {
+            element.remove();
+            continue;
+        }
+        if (!elements.has(element.tagName.toLowerCase())) {
+            while (element.firstChild)
+                element.parentNode?.insertBefore(element.firstChild, element);
+            element.remove();
+            continue;
+        }
+        const source = element.tagName === 'IMG' ? element.getAttribute('src') : null;
+        for (const attr of Array.from(element.attributes)) {
+            if (attr.name === 'style') {
+                const safe = attr.value.split(';').filter(declaration => {
+                    const colon = declaration.indexOf(':');
+                    return colon > 0 && allowedStyle.test(declaration.slice(0, colon).trim())
+                        && !/url\s*\(|expression|@|\\|[<>]/i.test(declaration.slice(colon + 1));
+                }).join(';');
+                element.setAttribute('style', safe);
+            }
+            else if (!(attributes.has(attr.name) || (attr.name === 'href' && attr.value.startsWith('#'))))
+                element.removeAttribute(attr.name);
+        }
+        if (source) {
+            try {
+                if (/^[a-z][a-z\d+.-]*:|^[/\\]/i.test(source))
+                    continue;
+                const image = await realpath(resolve(dirname(file), decodeURIComponent(source.split(/[?#]/)[0])));
+                const type = imageTypes[extname(image).toLowerCase()];
+                if (!type || !within(base, image) || hidden(base, image))
+                    continue;
+                const info = await stat(image);
+                if (!info.isFile() || info.size > 5_000_000)
+                    continue;
+                element.setAttribute('src', `data:${type};base64,${(await readFile(image)).toString('base64')}`);
+            }
+            catch { /* Missing/out-of-root images remain as their alt text. */ }
+        }
+    }
+    const tables = editableTables(original);
+    const rendered = Array.from(doc.querySelectorAll('table'));
+    if (rendered.length !== tables.length)
+        tables.forEach(t => { t.editable = false; });
+    tables.forEach((t, i) => { if (t.editable)
+        rendered[i]?.setAttribute('data-csync-table', String(t.index)); });
+    const channel = randomBytes(24).toString('hex');
+    const bridge = typeof __CSYNC_TABLE_BRIDGE__ === 'string' ? __CSYNC_TABLE_BRIDGE__ : tableEditorBridge.toString();
+    const script = nonce ? `<script nonce="${nonce}" data-channel="${channel}">(${bridge})()</script>` : '';
+    return { hash: sourceHash(original), channel, tables, html: `<!doctype html><html lang="ko"><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src ${nonce ? `'nonce-${nonce}'` : "'none'"}; img-src data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'"><meta name="viewport" content="width=device-width,initial-scale=1"><style>
+    *{box-sizing:border-box}body{margin:0;padding:24px;color:#172b4d;background:white;font:15px/1.7 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}main{max-width:760px;margin:auto}h1,h2,h3,h4{line-height:1.4}h1{font-size:26px}h2{font-size:22px}h3{font-size:18px}table{border-collapse:collapse;margin:16px 0}th,td{border:1px solid #c7cfdb;padding:8px;vertical-align:top;overflow-wrap:anywhere}th{background:#f0f3f8}td p,th p{margin:0}img{max-width:100%;height:auto}pre{padding:14px;background:#f4f6f9;overflow:auto}code{font-size:.88em;overflow-wrap:anywhere}blockquote{border-left:3px solid #c7cfdb;margin-left:0;padding-left:16px;color:#526078}a{color:#315fd8}hr{border:0;border-top:1px solid #dde3ec}
+    .csync-editing table[data-csync-table]{cursor:pointer}.csync-editing table[data-csync-table]:hover{outline:2px dashed #8192e3}.csync-selected{outline:3px solid #5466d8!important}.csync-resize{position:absolute;width:10px;cursor:col-resize;z-index:10;touch-action:none;border-left:2px solid #5466d8;background:#5466d82a}
+  </style></head><body><main>${doc.body.innerHTML}</main>${script}</body></html>` };
+}