@im-nobsidian/core 0.1.3 → 0.1.4

package/dist/index.js

@@ -12,6 +12,13 @@ import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
 
 // src/types/config.ts
+var DatabaseSyncSchema = z.object({
+  databaseId: z.string(),
+  localFolder: z.string(),
+  propertyMapping: z.record(z.string()).optional(),
+  pullFilter: z.unknown().optional(),
+  titleProperty: z.string().default("Name")
+});
 var ConfigSchema = z.object({
   version: z.literal(1),
   notion: z.object({
@@ -19,14 +26,16 @@ var ConfigSchema = z.object({
     rootPageId: z.string(),
     workspaceId: z.string().optional(),
     parentMode: z.enum(["page", "database"]).default("page"),
-    databaseId: z.string().optional()
+    databaseId: z.string().optional(),
+    databases: z.array(DatabaseSyncSchema).default([])
   }),
   sync: z.object({
     direction: z.enum(["push", "pull", "both"]).default("both"),
     conflictStrategy: z.enum(["local-first", "remote-first", "manual", "duplicate"]).default("manual"),
     autoSync: z.boolean().default(false),
     autoSyncInterval: z.number().min(30).max(3600).default(300),
-    deleteSync: z.boolean().default(false)
+    deleteSync: z.boolean().default(false),
+    syncFiles: z.boolean().default(true)
   }),
   paths: z.object({
     include: z.array(z.string()).default(["**/*"]),
@@ -51,14 +60,16 @@ var DEFAULT_CONFIG = {
   notion: {
     token: "",
     rootPageId: "",
-    parentMode: "page"
+    parentMode: "page",
+    databases: []
   },
   sync: {
     direction: "both",
     conflictStrategy: "manual",
     autoSync: false,
     autoSyncInterval: 300,
-    deleteSync: false
+    deleteSync: false,
+    syncFiles: true
   },
   paths: {
     include: ["**/*"],
@@ -257,6 +268,28 @@ CREATE TABLE IF NOT EXISTS sync_metadata (
 INSERT OR IGNORE INTO sync_metadata (key, value) VALUES ('schema_version', '1');
 `;
 
+// src/state/migrations/002-file-registry.ts
+var FILE_REGISTRY_MIGRATION = `
+CREATE TABLE IF NOT EXISTS file_registry (
+    id              TEXT PRIMARY KEY,
+    local_path      TEXT NOT NULL,
+    notion_page_id  TEXT NOT NULL,
+    file_upload_id  TEXT NOT NULL,
+    file_type       TEXT NOT NULL DEFAULT 'file',
+    file_hash       TEXT NOT NULL,
+    file_size       INTEGER NOT NULL DEFAULT 0,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
+
+    CONSTRAINT chk_file_type CHECK (file_type IN ('image', 'pdf', 'video', 'audio', 'file'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_file_registry_path ON file_registry(local_path);
+CREATE INDEX IF NOT EXISTS idx_file_registry_page ON file_registry(notion_page_id);
+
+UPDATE sync_metadata SET value = '2' WHERE key = 'schema_version';
+`;
+
 // src/state/state-db.ts
 var StateDB = class _StateDB {
   db;
@@ -276,6 +309,9 @@ var StateDB = class _StateDB {
     if (version < 1) {
       this.db.exec(INITIAL_MIGRATION);
     }
+    if (version < 2) {
+      this.db.exec(FILE_REGISTRY_MIGRATION);
+    }
   }
   getSchemaVersion() {
     try {
@@ -406,6 +442,49 @@ var StateDB = class _StateDB {
   setMeta(key, value) {
     this.db.prepare("INSERT OR REPLACE INTO sync_metadata (key, value) VALUES (?, ?)").run(key, value);
   }
+  // --- file_registry ---
+  isFileRegistered(localPath) {
+    const row = this.db.prepare("SELECT 1 FROM file_registry WHERE local_path = ?").get(localPath);
+    return !!row;
+  }
+  getFileRegistry(localPath) {
+    const row = this.db.prepare("SELECT * FROM file_registry WHERE local_path = ?").get(localPath);
+    return row ? this.mapFileRegistryRow(row) : null;
+  }
+  getFilesByPageId(notionPageId) {
+    const rows = this.db.prepare("SELECT * FROM file_registry WHERE notion_page_id = ?").all(notionPageId);
+    return rows.map((r) => this.mapFileRegistryRow(r));
+  }
+  registerFile(entry) {
+    const id = generateId();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO file_registry
+          (id, local_path, notion_page_id, file_upload_id, file_type, file_hash, file_size)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      entry.localPath,
+      entry.notionPageId,
+      entry.fileUploadId,
+      entry.fileType,
+      entry.fileHash,
+      entry.fileSize
+    );
+  }
+  deleteFileRegistry(localPath) {
+    this.db.prepare("DELETE FROM file_registry WHERE local_path = ?").run(localPath);
+  }
+  mapFileRegistryRow(row) {
+    return {
+      id: row.id,
+      localPath: row.local_path,
+      notionPageId: row.notion_page_id,
+      fileUploadId: row.file_upload_id,
+      fileType: row.file_type,
+      fileHash: row.file_hash,
+      fileSize: row.file_size
+    };
+  }
   // --- preserve markers ---
   storePreserveMarkers(path, markers) {
     if (markers.length === 0) {
@@ -817,7 +896,8 @@ var NotionClient = class {
       () => this.client.dataSources.query({
         data_source_id: databaseId,
         start_cursor: options?.startCursor,
-        page_size: options?.pageSize ?? 100
+        page_size: options?.pageSize ?? 100,
+        filter: options?.filter
       })
     );
     return {
@@ -825,6 +905,27 @@ var NotionClient = class {
       nextCursor: response.next_cursor
     };
   }
+  async queryAllDatabasePages(databaseId, filter) {
+    const all = [];
+    let cursor;
+    do {
+      const response = await this.queryDatabase(databaseId, {
+        startCursor: cursor,
+        pageSize: 100,
+        filter
+      });
+      all.push(...response.results);
+      cursor = response.nextCursor ?? void 0;
+    } while (cursor);
+    return all;
+  }
+  async getDataSourceId(databaseId) {
+    const db = await this.withRateLimit(
+      () => this.client.databases.retrieve({ database_id: databaseId })
+    );
+    const dataSources = db.data_sources;
+    return dataSources?.[0]?.id ?? databaseId;
+  }
   async archivePage(pageId) {
     await this.withRateLimit(() => this.client.pages.update({ page_id: pageId, archived: true }));
   }
@@ -873,15 +974,18 @@ var NotionClient = class {
       () => this.client.fileUploads.create({ filename, content_type: contentType })
     );
     const fileUploadId = upload.id;
-    await this.withRateLimit(
+    const sendResult = await this.withRateLimit(
       () => this.client.fileUploads.send({
         file_upload_id: fileUploadId,
         file: { data: fileData, filename }
       })
     );
-    await this.withRateLimit(
-      () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
-    );
+    const status = sendResult.status;
+    if (status === "pending") {
+      await this.withRateLimit(
+        () => this.client.fileUploads.complete({ file_upload_id: fileUploadId })
+      );
+    }
     return fileUploadId;
   }
   // ─── Search & Navigation ───
@@ -2855,6 +2959,265 @@ var ImageHandler = class {
     return ext ? `.${ext[1].toLowerCase()}` : null;
   }
 };
+var EXTENSION_TO_BLOCK_TYPE = {
+  ".png": "image",
+  ".jpg": "image",
+  ".jpeg": "image",
+  ".gif": "image",
+  ".svg": "image",
+  ".webp": "image",
+  ".ico": "image",
+  ".bmp": "image",
+  ".tiff": "image",
+  ".tif": "image",
+  ".avif": "image",
+  ".apng": "image",
+  ".heic": "image",
+  ".pdf": "pdf",
+  ".mp4": "video",
+  ".mov": "video",
+  ".webm": "video",
+  ".avi": "video",
+  ".mkv": "video",
+  ".flv": "video",
+  ".wmv": "video",
+  ".m4v": "video",
+  ".mpeg": "video",
+  ".ogv": "video",
+  ".3gp": "video",
+  ".mp3": "audio",
+  ".wav": "audio",
+  ".ogg": "audio",
+  ".m4a": "audio",
+  ".flac": "audio",
+  ".aac": "audio",
+  ".wma": "audio",
+  ".opus": "audio",
+  ".weba": "audio"
+};
+var EXTENSION_TO_MIME2 = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".avif": "image/avif",
+  ".heic": "image/heic",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".rar": "application/vnd.rar",
+  ".7z": "application/x-7z-compressed",
+  ".py": "text/x-python",
+  ".js": "text/javascript",
+  ".ts": "text/typescript",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".xml": "application/xml",
+  ".hwp": "application/x-hwp",
+  ".xls": "application/vnd.ms-excel",
+  ".doc": "application/msword",
+  ".ppt": "application/vnd.ms-powerpoint"
+};
+function getBlockType(filename) {
+  const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+  if (!ext) return "file";
+  return EXTENSION_TO_BLOCK_TYPE[ext] ?? "file";
+}
+function getMimeType(filename) {
+  const ext = filename.match(/\.[^.]+$/)?.[0]?.toLowerCase();
+  if (!ext) return "application/octet-stream";
+  return EXTENSION_TO_MIME2[ext] ?? "application/octet-stream";
+}
+function getFolderPath(filePath) {
+  const parts = filePath.split("/");
+  return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+}
+var FileHandler = class {
+  constructor(vaultFs, notionClient, stateDb) {
+    this.vaultFs = vaultFs;
+    this.notionClient = notionClient;
+    this.stateDb = stateDb;
+  }
+  vaultFs;
+  notionClient;
+  stateDb;
+  sema = new Sema(2);
+  async pushFilesForFolder(folderPageId, folderPath) {
+    const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    const folderFiles = allFiles.filter((f) => getFolderPath(f.path) === folderPath);
+    if (folderFiles.length === 0) return [];
+    const results = [];
+    for (const file of folderFiles) {
+      if (this.stateDb.isFileRegistered(file.path)) {
+        const existing = this.stateDb.getFileRegistry(file.path);
+        if (existing) {
+          const buffer = await this.vaultFs.readBinary(file.path);
+          const currentHash = createHash("sha256").update(buffer).digest("hex");
+          if (existing.fileHash === currentHash) continue;
+        }
+      }
+      await this.sema.acquire();
+      try {
+        const result = await this.uploadFile(file, folderPageId);
+        if (result) results.push(result);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${file.path}):`, error);
+      } finally {
+        this.sema.release();
+      }
+    }
+    return results;
+  }
+  async pushAllFiles() {
+    const allFiles = await this.vaultFs.listNonMarkdownFiles();
+    if (allFiles.length === 0) return [];
+    const filesByFolder = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const folder = getFolderPath(file.path);
+      const list = filesByFolder.get(folder) ?? [];
+      list.push(file);
+      filesByFolder.set(folder, list);
+    }
+    const results = [];
+    for (const [folderPath, files] of filesByFolder) {
+      const folderRecord = folderPath ? this.stateDb.getByPath(folderPath) : this.stateDb.getByPath("__root__");
+      const folderPageId = folderRecord?.notionPageId;
+      if (!folderPageId) {
+        getLogger().warn(
+          `\uD3F4\uB354 \uD398\uC774\uC9C0 \uC5C6\uC74C, \uD30C\uC77C \uC2A4\uD0B5: ${folderPath || "(\uB8E8\uD2B8)"} (${files.length}\uAC1C)`
+        );
+        continue;
+      }
+      for (const file of files) {
+        if (this.stateDb.isFileRegistered(file.path)) {
+          const existing = this.stateDb.getFileRegistry(file.path);
+          if (existing) {
+            const buffer = await this.vaultFs.readBinary(file.path);
+            const currentHash = createHash("sha256").update(buffer).digest("hex");
+            if (existing.fileHash === currentHash) continue;
+          }
+        }
+        await this.sema.acquire();
+        try {
+          const result = await this.uploadFile(file, folderPageId);
+          if (result) results.push(result);
+        } catch (error) {
+          getLogger().warn(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC2E4\uD328 (${file.path}):`, error);
+        } finally {
+          this.sema.release();
+        }
+      }
+    }
+    return results;
+  }
+  async downloadFileBlock(url, filename, targetFolder) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: ${response.status} ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    const localPath = targetFolder ? `${targetFolder}/${filename}` : filename;
+    await this.vaultFs.ensureFolder(targetFolder || ".");
+    await this.vaultFs.writeBinary(localPath, buffer);
+    return { url, localPath, hash, size: buffer.length };
+  }
+  async downloadFileBlocks(blocks, targetFolder) {
+    const results = [];
+    for (const block of blocks) {
+      const filename = this.extractFilename(block.url, block.caption);
+      if (this.stateDb.isFileRegistered(`${targetFolder}/${filename}`)) continue;
+      await this.sema.acquire();
+      try {
+        const result = await this.downloadFileBlock(block.url, filename, targetFolder);
+        results.push(result);
+      } catch (error) {
+        getLogger().warn(`\uD30C\uC77C \uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 (${block.url}):`, error);
+      } finally {
+        this.sema.release();
+      }
+    }
+    return results;
+  }
+  async uploadFile(file, parentPageId) {
+    const buffer = await this.vaultFs.readBinary(file.path);
+    const filename = file.path.split("/").pop() ?? "file";
+    const contentType = getMimeType(filename);
+    const blockType = getBlockType(filename);
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    const blob = new Blob([buffer], { type: contentType });
+    const fileUploadId = await this.notionClient.uploadFile(blob, filename, contentType);
+    const block = this.createFileBlock(blockType, fileUploadId);
+    await this.notionClient.appendChildren(parentPageId, [block]);
+    this.stateDb.registerFile({
+      localPath: file.path,
+      notionPageId: parentPageId,
+      fileUploadId,
+      fileType: blockType,
+      fileHash: hash,
+      fileSize: file.size
+    });
+    getLogger().info(`\uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC: ${file.path} \u2192 ${blockType} \uBE14\uB85D`);
+    return { localPath: file.path, fileUploadId, blockType };
+  }
+  createFileBlock(blockType, fileUploadId) {
+    const fileRef = {
+      type: "file_upload",
+      file_upload: { id: fileUploadId }
+    };
+    switch (blockType) {
+      case "image":
+        return { type: "image", image: fileRef };
+      case "pdf":
+        return { type: "pdf", pdf: fileRef };
+      case "video":
+        return { type: "video", video: fileRef };
+      case "audio":
+        return { type: "audio", audio: fileRef };
+      case "file":
+      default:
+        return { type: "file", file: fileRef };
+    }
+  }
+  extractFilename(url, caption) {
+    if (caption) {
+      const safe = caption.replace(/[^a-zA-Z0-9가-힣._\s-]/g, "").trim();
+      if (safe) return safe;
+    }
+    try {
+      const pathname = new URL(url).pathname;
+      const segments = pathname.split("/");
+      const last = segments[segments.length - 1];
+      if (last && last.includes(".")) return decodeURIComponent(last);
+    } catch {
+    }
+    const ext = url.match(/\.(png|jpg|jpeg|gif|pdf|mp4|mp3|docx|xlsx|zip|webp)(\?|$)/i);
+    return `file-${Date.now()}${ext ? `.${ext[1]}` : ""}`;
+  }
+};
 
 // src/utils/sanitize.ts
 var INVALID_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
@@ -3244,6 +3607,253 @@ function unescapePipes(content) {
   }
   return result.join("\n");
 }
+var DatabaseSyncer = class {
+  constructor(config, stateDb, notionClient, vaultFs, pipeline, imageHandler) {
+    this.config = config;
+    this.stateDb = stateDb;
+    this.notionClient = notionClient;
+    this.vaultFs = vaultFs;
+    this.pipeline = pipeline;
+    this.imageHandler = imageHandler;
+    this.propertyMapper.setWikilinkResolver({
+      resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
+      resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
+    });
+  }
+  config;
+  stateDb;
+  notionClient;
+  vaultFs;
+  pipeline;
+  imageHandler;
+  propertyMapper = new PropertyMapper();
+  async pullAll() {
+    const databases = this.config.notion.databases;
+    if (!databases || databases.length === 0) {
+      return { created: 0, updated: 0, failed: [] };
+    }
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const dbConfig of databases) {
+      try {
+        const result = await this.pullDatabase(dbConfig);
+        created += result.created;
+        updated += result.updated;
+        failed.push(...result.failed);
+      } catch (error) {
+        getLogger().warn(`[DB Sync] DB ${dbConfig.databaseId} pull \uC2E4\uD328:`, error);
+        failed.push({
+          path: dbConfig.localFolder,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { created, updated, failed };
+  }
+  async pushAll() {
+    const databases = this.config.notion.databases;
+    if (!databases || databases.length === 0) {
+      return { created: 0, updated: 0, failed: [] };
+    }
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const dbConfig of databases) {
+      try {
+        const result = await this.pushDatabase(dbConfig);
+        created += result.created;
+        updated += result.updated;
+        failed.push(...result.failed);
+      } catch (error) {
+        getLogger().warn(`[DB Sync] DB ${dbConfig.databaseId} push \uC2E4\uD328:`, error);
+        failed.push({
+          path: dbConfig.localFolder,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { created, updated, failed };
+  }
+  async pullDatabase(dbConfig) {
+    const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
+    this.propertyMapper.loadSchema(schema);
+    await this.vaultFs.ensureFolder(dbConfig.localFolder);
+    const pages = await this.notionClient.queryAllDatabasePages(
+      dbConfig.databaseId,
+      dbConfig.pullFilter
+    );
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const page of pages) {
+      try {
+        const record = this.stateDb.getByNotionId(page.id);
+        if (record) {
+          if (page.last_edited_time === record.notionLastEdited) continue;
+          await this.pullDatabasePage(page, dbConfig);
+          updated++;
+        } else {
+          await this.pullDatabasePage(page, dbConfig);
+          created++;
+        }
+      } catch (error) {
+        failed.push({
+          path: `${dbConfig.localFolder}/${page.id}`,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
+    return { created, updated, failed };
+  }
+  async pullDatabasePage(page, dbConfig) {
+    const title = this.notionClient.extractTitle(page);
+    const safeName = sanitizeFileName(title);
+    const properties = this.propertyMapper.fromNotionProperties(
+      page.properties
+    );
+    properties.title = title;
+    let markdown = "";
+    try {
+      const mdResult = await this.notionClient.getPageMarkdown(page.id);
+      markdown = notionEnhancedToObsidian(mdResult.markdown);
+    } catch {
+    }
+    if (this.config.conversion.imageDownload === "immediate" && markdown) {
+      const imageResult = await this.imageHandler.downloadAllImages(markdown, title);
+      markdown = imageResult.content;
+    }
+    const existingRecord = this.stateDb.getByNotionId(page.id);
+    const filePath = existingRecord?.obsidianPath ?? `${dbConfig.localFolder}/${safeName}.md`;
+    const finalContent = this.pipeline.convertToMarkdown(
+      markdown,
+      {
+        direction: "pull",
+        path: "markdown-api",
+        filePath,
+        parentMode: "database"
+      },
+      { properties }
+    );
+    await this.vaultFs.ensureFolder(dbConfig.localFolder);
+    await this.vaultFs.writeFile(filePath, finalContent);
+    const hash = computeHash(finalContent);
+    this.stateDb.transaction(() => {
+      this.stateDb.upsert({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        notionParentId: dbConfig.databaseId,
+        contentHash: hash,
+        notionLastEdited: page.last_edited_time,
+        localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+        syncDirection: "both",
+        fileType: "db-row",
+        status: "synced",
+        baseSnapshot: Buffer.from(finalContent, "utf-8")
+      });
+      this.stateDb.upsertWikilink({
+        obsidianPath: filePath,
+        notionPageId: page.id,
+        title,
+        aliases: extractAliases(properties)
+      });
+    });
+    return filePath;
+  }
+  async pushDatabase(dbConfig) {
+    const schema = await this.notionClient.getDatabaseSchema(dbConfig.databaseId);
+    this.propertyMapper.loadSchema(schema);
+    const allFiles = await this.vaultFs.listMarkdownFiles();
+    const prefix = dbConfig.localFolder.endsWith("/") ? dbConfig.localFolder : dbConfig.localFolder + "/";
+    const dbFiles = allFiles.filter((f) => f.path.startsWith(prefix));
+    let created = 0;
+    let updated = 0;
+    const failed = [];
+    for (const file of dbFiles) {
+      try {
+        const content = await this.vaultFs.readFile(file.path);
+        const hash = computeHash(content);
+        const record = this.stateDb.getByPath(file.path);
+        if (record?.contentHash === hash) continue;
+        const parsed = matter(content);
+        const frontmatter = parsed.data;
+        const body = parsed.content;
+        const title = frontmatter.title ?? extractTitleFromPath(file.path);
+        delete frontmatter.title;
+        const notionProps = this.propertyMapper.toNotionProperties(frontmatter, title);
+        const enhanced = obsidianToNotionEnhanced(body.trim());
+        if (record?.notionPageId) {
+          await this.notionClient.updatePageProperties(record.notionPageId, notionProps);
+          try {
+            await this.notionClient.replacePageMarkdown(record.notionPageId, enhanced);
+          } catch {
+          }
+          const updatedPage = await this.notionClient.getPage(record.notionPageId);
+          this.stateDb.transaction(() => {
+            this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
+            this.stateDb.updateStatus(record.id, "synced");
+            this.stateDb.setNotionLastEdited(record.id, updatedPage.last_edited_time);
+          });
+          updated++;
+        } else {
+          const page = await this.notionClient.createPageWithMarkdown({
+            parentId: dbConfig.databaseId,
+            parentType: "database",
+            title,
+            markdown: enhanced,
+            properties: notionProps
+          });
+          this.stateDb.transaction(() => {
+            this.stateDb.upsert({
+              obsidianPath: file.path,
+              notionPageId: page.id,
+              notionParentId: dbConfig.databaseId,
+              contentHash: hash,
+              notionLastEdited: page.last_edited_time,
+              localLastModified: (/* @__PURE__ */ new Date()).toISOString(),
+              syncDirection: "both",
+              fileType: "db-row",
+              status: "synced",
+              baseSnapshot: Buffer.from(content, "utf-8")
+            });
+            this.stateDb.upsertWikilink({
+              obsidianPath: file.path,
+              notionPageId: page.id,
+              title,
+              aliases: extractAliases(frontmatter)
+            });
+          });
+          created++;
+        }
+      } catch (error) {
+        failed.push({
+          path: file.path,
+          operation: "create",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    getLogger().info(`[DB Sync] ${dbConfig.localFolder}: ${created} \uC0DD\uC131, ${updated} \uC5C5\uB370\uC774\uD2B8`);
+    return { created, updated, failed };
+  }
+};
+function extractAliases(properties) {
+  const raw = properties.aliases ?? properties.alias;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
+  if (typeof raw === "string")
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return [];
+}
+function extractTitleFromPath(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1] ?? "";
+  return filename.replace(/\.md$/, "");
+}
 
 // src/sync/orchestrator.ts
 var SyncOrchestrator = class {
@@ -3258,7 +3868,16 @@ var SyncOrchestrator = class {
     });
     this.blockConverter = new BlockConverter();
     this.imageHandler = new ImageHandler(vaultFs, config.paths.attachments, notionClient);
+    this.fileHandler = new FileHandler(vaultFs, notionClient, stateDb);
     this.propertyMapper = new PropertyMapper();
+    this.databaseSyncer = new DatabaseSyncer(
+      config,
+      stateDb,
+      notionClient,
+      vaultFs,
+      this.pipeline,
+      this.imageHandler
+    );
     this.propertyMapper.setWikilinkResolver({
       resolve: (title) => stateDb.resolveWikilink(title)?.notionPageId ?? null,
       resolvePageId: (pageId) => stateDb.resolvePageId(pageId)?.title ?? null
@@ -3273,6 +3892,8 @@ var SyncOrchestrator = class {
   pipeline;
   blockConverter;
   imageHandler;
+  fileHandler;
+  databaseSyncer;
   propertyMapper;
   dbSchemaLoaded = false;
   async push(options) {
@@ -3357,6 +3978,26 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    if (this.config.sync.syncFiles !== false) {
+      try {
+        const fileResults = await this.fileHandler.pushAllFiles();
+        if (fileResults.length > 0) {
+          getLogger().info(`[Im-Nobsidian] ${fileResults.length}\uAC1C \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC644\uB8CC`);
+        }
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] \uD30C\uC77C \uC5C5\uB85C\uB4DC \uC911 \uC624\uB958:", error);
+      }
+    }
+    if ((this.config.notion.databases?.length ?? 0) > 0) {
+      try {
+        const dbResult = await this.databaseSyncer.pushAll();
+        created += dbResult.created;
+        updated += dbResult.updated;
+        failed.push(...dbResult.failed);
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] DB Push \uC911 \uC624\uB958:", error);
+      }
+    }
     this.stateDb.setMeta("last_push_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("push_in_progress", "");
@@ -3450,6 +4091,20 @@ var SyncOrchestrator = class {
       }
     });
     await Promise.all(tasks.map((t) => t()));
+    if ((this.config.notion.databases?.length ?? 0) > 0) {
+      try {
+        const dbResult = await this.databaseSyncer.pullAll();
+        created += dbResult.created;
+        updated += dbResult.updated;
+        failed.push(...dbResult.failed);
+        if (dbResult.created + dbResult.updated > 0) {
+          const dbPaths = this.stateDb.getByStatus("synced").filter((r) => r.fileType === "db-row").map((r) => r.obsidianPath);
+          writtenPaths.push(...dbPaths.slice(-dbResult.created - dbResult.updated));
+        }
+      } catch (error) {
+        getLogger().warn("[Im-Nobsidian] DB Pull \uC911 \uC624\uB958:", error);
+      }
+    }
     this.stateDb.setMeta("last_pull_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("last_sync_at", (/* @__PURE__ */ new Date()).toISOString());
     this.stateDb.setMeta("pull_in_progress", "");
@@ -3594,7 +4249,7 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(content, "utf-8")
       });
-      const aliases = extractAliases(conversionResult.properties);
+      const aliases = extractAliases2(conversionResult.properties);
       this.stateDb.upsertWikilink({
         obsidianPath: path,
         notionPageId: page.id,
@@ -3634,7 +4289,7 @@ var SyncOrchestrator = class {
     const updatedPage = await this.notionClient.getPage(record.notionPageId);
     const hash = computeHash(content);
     const title = extractTitle(path);
-    const aliases = extractAliases(conversionResult.properties);
+    const aliases = extractAliases2(conversionResult.properties);
     this.stateDb.transaction(() => {
       this.stateDb.updateHash(record.id, hash, Buffer.from(content, "utf-8"));
       this.stateDb.updateStatus(record.id, "synced");
@@ -3798,7 +4453,7 @@ var SyncOrchestrator = class {
         status: "synced",
         baseSnapshot: Buffer.from(finalContent, "utf-8")
       });
-      const aliases = extractAliases(properties);
+      const aliases = extractAliases2(properties);
       this.stateDb.upsertWikilink({
         obsidianPath: filePath,
         notionPageId: pageId,
@@ -4017,8 +4672,13 @@ var SyncOrchestrator = class {
           const baseEnhanced = obsidianToNotionEnhanced(baseSnapshot.toString("utf-8"));
           const patches = this.computePatches(baseEnhanced, enhanced);
           if (patches.length > 0 && patches.length <= 20) {
-            await this.notionClient.updatePageMarkdownPartial(pageId, patches);
-            return;
+            try {
+              await this.notionClient.updatePageMarkdownPartial(pageId, patches);
+              return;
+            } catch {
+              await this.notionClient.replacePageMarkdown(pageId, enhanced);
+              return;
+            }
           }
         }
         await this.notionClient.replacePageMarkdown(pageId, enhanced);
@@ -4133,7 +4793,7 @@ function extractTitle(filePath) {
   const filename = parts[parts.length - 1] ?? "";
   return filename.replace(/\.md$/, "");
 }
-function extractAliases(properties) {
+function extractAliases2(properties) {
   const raw = properties.aliases ?? properties.alias;
   if (!raw) return [];
   if (Array.isArray(raw)) return raw.filter((a) => typeof a === "string");
@@ -4205,6 +4865,11 @@ var NodeVaultFS = class {
     await this.walkDir(this.rootPath, files);
     return files;
   }
+  async listNonMarkdownFiles() {
+    const files = [];
+    await this.walkDirNonMd(this.rootPath, files);
+    return files;
+  }
   matchesPattern(relativePath, pattern) {
     if (pattern === "**/*" || pattern === "**") return true;
     if (pattern.endsWith("/**")) {
@@ -4227,6 +4892,25 @@ var NodeVaultFS = class {
     }
     return this.excludePatterns.some((p) => this.matchesPattern(relativePath, p));
   }
+  async walkDirNonMd(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.name.startsWith(".")) continue;
+      const relativePath = relative(this.rootPath, fullPath);
+      if (this.isExcluded(relativePath)) continue;
+      if (entry.isDirectory()) {
+        await this.walkDirNonMd(fullPath, result);
+      } else if (entry.isFile() && !entry.name.endsWith(".md")) {
+        const fileStat = await stat(fullPath);
+        result.push({
+          path: relativePath,
+          size: fileStat.size,
+          mtime: fileStat.mtime.toISOString()
+        });
+      }
+    }
+  }
   async walkDir(dir, result) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -4707,6 +5391,6 @@ var WatchSyncService = class {
   }
 };
 
-export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, EmbedResolver, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, ImageHandler, InlineDBParser, LocalImageRestorer, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, generateId, getLogger, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, threeWayMerge };
+export { BlockConverter, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, ConfigManager, ConfigSchema, ConflictResolver, ConversionPipeline, DEFAULT_CONFIG, DatabaseSyncer, EmbedResolver, FileHandler, FileWatcher, FrontmatterExtractor, FrontmatterGenerator, HtmlAnnotationStripper, ImageHandler, InlineDBParser, LocalImageRestorer, MathNormalizer, MentionToWikilink, NodeVaultFS, NotionBlockBuilder, NotionClient, PreserveMarkerCollector, PreserveMarkerInjector, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, StateDB, SyncOrchestrator, TreeMapper, UnsupportedBlockStripper, WatchSyncService, WikilinkResolver, computeBufferHash, computeHash, createDefaultPipeline, generateId, getLogger, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, threeWayMerge };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map