pinokiod 7.2.17 → 7.2.18

package/server/features/{drafts → notes}/registry_import.js

@@ -145,10 +145,10 @@ function buildAuthorizeUrl(req, registryBase, item, bundle) {
   return authorizeUrl
 }
 
-async function findDraftById(drafts, id) {
+async function findNoteById(notes, id) {
   const normalized = String(id || "").trim()
   if (!normalized) return null
-  const items = await drafts.listPending({})
+  const items = await notes.listPending({})
   return (items || []).find((item) => item && item.id === normalized) || null
 }
 
@@ -168,9 +168,9 @@ function normalizeParent(parent) {
 }
 
 async function buildDraftBundle(item, query = {}) {
-  const markdown = await fs.promises.readFile(item.postPath, "utf8")
-  const resultDir = path.dirname(item.postPath)
-  const titleFallback = item.title || (item.workspaceName ? `Draft for ${item.workspaceName}` : "Draft")
+  const markdown = await fs.promises.readFile(item.notePath, "utf8")
+  const resultDir = path.dirname(item.notePath)
+  const titleFallback = item.title || (item.workspaceName ? `Note for ${item.workspaceName}` : "Note")
   const extracted = extractTitleAndBody(markdown, titleFallback)
   const metadataTitle = item.metadata && typeof item.metadata.title === "string"
     ? normalizeTitle(item.metadata.title)
@@ -195,17 +195,17 @@ function preflightBundle(bundle, options = {}) {
   const maxFiles = Number(options.maxFiles || DEFAULT_MAX_FILES)
   const maxFileBytes = Number(options.maxFileBytes || DEFAULT_MAX_FILE_BYTES)
   if (!bundle.title) {
-    return "Draft title is missing."
+    return "Note title is missing."
   }
   if (!isRegistryPostPublish(bundle.publish)) {
-    return "This draft is not configured for registry publishing."
+    return "This note is not configured for registry publishing."
   }
   if (bundle.media.length > maxFiles) {
-    return `Draft has ${bundle.media.length} media files. The registry limit is ${maxFiles}.`
+    return `Note has ${bundle.media.length} media files. The registry limit is ${maxFiles}.`
   }
   const missing = bundle.media.filter((item) => !item.exists)
   if (missing.length > 0) {
-    return `Draft references missing media: ${missing.map((item) => item.ref).join(", ")}`
+    return `Note references missing media: ${missing.map((item) => item.ref).join(", ")}`
   }
   const oversized = bundle.media.find((item) => item.bytes > maxFileBytes)
   if (oversized) {
@@ -268,10 +268,10 @@ async function uploadBundle(registryBase, token, bundle) {
   return response.data || {}
 }
 
-async function uploadDraftFromRequest(drafts, query, token, registryBase, options = {}) {
-  const item = await findDraftById(drafts, query.draft)
+async function uploadDraftFromRequest(notes, query, token, registryBase, options = {}) {
+  const item = await findNoteById(notes, query.draft)
   if (!item) {
-    const error = new Error("The local draft is no longer available.")
+    const error = new Error("The local note is no longer available.")
     error.status = 404
     throw error
   }
@@ -286,17 +286,17 @@ async function uploadDraftFromRequest(drafts, query, token, registryBase, option
 }
 
 function registerDraftImportRoutes(app, options = {}) {
-  const drafts = options.drafts
-  if (!drafts) {
-    throw new Error("drafts is required")
+  const notes = options.notes
+  if (!notes) {
+    throw new Error("notes is required")
   }
   const defaultRegistryUrl = options.defaultRegistryUrl || "https://beta.pinokio.co"
   const router = express.Router()
 
   router.get("/registry/draft-import/authorize-url", asyncHandler(async (req, res) => {
-    const item = await findDraftById(drafts, req.query.draft)
+    const item = await findNoteById(notes, req.query.draft)
     if (!item) {
-      return res.status(404).json({ error: "The local draft is no longer available." })
+      return res.status(404).json({ error: "The local note is no longer available." })
     }
     const bundle = await buildDraftBundle(item, req.query)
     const problem = preflightBundle(bundle, options)
@@ -316,14 +316,14 @@ function registerDraftImportRoutes(app, options = {}) {
   }))
 
   router.get("/registry/draft-import/start", asyncHandler(async (req, res) => {
-    const item = await findDraftById(drafts, req.query.draft)
+    const item = await findNoteById(notes, req.query.draft)
     if (!item) {
-      return renderMessage(res, 404, "Draft not found", "The local draft is no longer available.")
+      return renderMessage(res, 404, "Note not found", "The local note is no longer available.")
     }
     const bundle = await buildDraftBundle(item, req.query)
     const problem = preflightBundle(bundle, options)
     if (problem) {
-      return renderMessage(res, 400, "Draft is not ready", problem)
+      return renderMessage(res, 400, "Note is not ready", problem)
     }
     const registryBase = normalizeRegistryBase(req.query.registry, defaultRegistryUrl)
     if (!registryBase) {
@@ -354,7 +354,7 @@ function registerDraftImportRoutes(app, options = {}) {
         app: req.body && req.body.app ? String(req.body.app) : ""
       })
       const result = await uploadDraftFromRequest(
-        drafts,
+        notes,
         { draft: req.body && req.body.draft, app: req.body && req.body.app },
         token,
         registryBase,
@@ -392,7 +392,7 @@ function registerDraftImportRoutes(app, options = {}) {
       return renderMessage(res, 400, "Registry unavailable", "The registry URL is invalid.")
     }
     try {
-      const result = await uploadDraftFromRequest(drafts, req.query, token, registryBase, options)
+      const result = await uploadDraftFromRequest(notes, req.query, token, registryBase, options)
       if (result && result.editUrl) {
         return res.redirect(String(result.editUrl))
       }

package/server/features/notes/routes.js

@@ -0,0 +1,156 @@
+const express = require("express")
+const path = require("path")
+const registerDraftImportRoutes = require("./registry_import")
+
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next)
+  }
+}
+
+function isInside(candidate, parent) {
+  const relative = path.relative(parent, candidate)
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+function parsePublishConfig(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(value)
+  } catch (_) {
+    return null
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null
+  }
+  const target = String(parsed.target || "").trim().toLowerCase()
+  const type = String(parsed.type || "post").trim().toLowerCase()
+  if (target !== "registry" || type !== "post") {
+    return null
+  }
+  const publish = { target: "registry", type: "post" }
+  const parent = parsed.parent && typeof parsed.parent === "object" && !Array.isArray(parsed.parent)
+    ? parsed.parent
+    : null
+  const parentType = parent ? String(parent.type || "").trim().toLowerCase() : ""
+  const parentUrl = parent ? String(parent.url || parent.repoUrl || "").trim() : ""
+  if (parentType === "app" && parentUrl) {
+    publish.parent = { type: "app", url: parentUrl }
+  }
+  return publish
+}
+
+function registerNoteRoutes(app, options = {}) {
+  const notes = options.notes
+  if (!notes) {
+    throw new Error("notes is required")
+  }
+  const kernel = options.kernel
+
+  const router = express.Router()
+  router.get("/notes", asyncHandler(async (req, res) => {
+    const cwd = typeof req.query.cwd === "string" ? req.query.cwd : ""
+    if (cwd && typeof notes.inspectWorkspace === "function") {
+      const resolvedCwd = path.resolve(cwd)
+      const home = kernel && kernel.homedir ? path.resolve(kernel.homedir) : ""
+      if (!home || isInside(resolvedCwd, home)) {
+        const publish = parsePublishConfig(req.query.publish)
+        const note = publish ? { publish } : undefined
+        await notes.inspectWorkspace({ cwd: resolvedCwd, note }).catch(() => null)
+      }
+    }
+    const items = await notes.listPending({ cwd })
+    res.json({
+      ok: true,
+      items
+    })
+  }))
+
+  router.get("/notes/:id/media/:index", asyncHandler(async (req, res) => {
+    const item = typeof notes.getPendingById === "function"
+      ? await notes.getPendingById(req.params.id)
+      : null
+    if (!item) {
+      res.status(404).send("Note not found")
+      return
+    }
+    const index = Number(req.params.index)
+    const media = Array.isArray(item.media) && Number.isInteger(index)
+      ? item.media[index]
+      : null
+    if (!media || !media.exists || !media.path) {
+      res.status(404).send("Media not found")
+      return
+    }
+    const filePath = path.resolve(media.path)
+    const basePath = path.resolve(item.resultDir)
+    const relative = path.relative(basePath, filePath)
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+      res.status(403).send("Media path is outside the note")
+      return
+    }
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(filePath)
+  }))
+
+  router.put("/notes/:id", express.text({ type: "*/*", limit: "6mb" }), asyncHandler(async (req, res) => {
+    if (typeof notes.savePendingById !== "function") {
+      res.status(501).json({ ok: false, error: "Note editing is unavailable." })
+      return
+    }
+    const markdown = typeof req.body === "string"
+      ? req.body
+      : (req.body && typeof req.body.markdown === "string"
+      ? req.body.markdown
+      : null)
+    if (markdown === null) {
+      res.status(400).json({ ok: false, error: "markdown is required" })
+      return
+    }
+    const revision = typeof req.get("x-pinokio-note-revision") === "string"
+      ? req.get("x-pinokio-note-revision")
+      : (req.body && typeof req.body.revision === "string"
+      ? req.body.revision
+      : "")
+    try {
+      const item = await notes.savePendingById(req.params.id, { markdown, revision })
+      if (!item) {
+        res.status(404).json({ ok: false, error: "Note not found" })
+        return
+      }
+      res.json({ ok: true, item })
+    } catch (error) {
+      if (error && error.code === "NOTE_CONFLICT") {
+        res.status(409).json({
+          ok: false,
+          error: error.message,
+          item: error.item || null
+        })
+        return
+      }
+      if (error && (error.code === "NOTE_TOO_LARGE" || error.code === "NOTE_INVALID_PATH")) {
+        res.status(400).json({ ok: false, error: error.message })
+        return
+      }
+      throw error
+    }
+  }))
+
+  router.get("/notes.js", (req, res) => {
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(path.resolve(__dirname, "public", "notes.js"))
+  })
+
+  router.get("/notes.css", (req, res) => {
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(path.resolve(__dirname, "public", "notes.css"))
+  })
+
+  app.use(router)
+  registerDraftImportRoutes(app, options)
+}
+
+module.exports = registerNoteRoutes

package/server/features/notes/service.js

@@ -0,0 +1,326 @@
+const fs = require("fs")
+const path = require("path")
+const crypto = require("crypto")
+const {
+  RESULT_RELATIVE_DIR,
+  NOTE_FILENAME,
+  METADATA_FILENAME,
+  buildExcerpt,
+  describeMediaRefs,
+  extractTitle,
+  parseNoteMetadata
+} = require("./parser")
+
+const MAX_MARKDOWN_BYTES = 5 * 1024 * 1024
+
+function createHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 24)
+}
+
+function clonePlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null
+  }
+  try {
+    return JSON.parse(JSON.stringify(value))
+  } catch (_) {
+    return null
+  }
+}
+
+function normalizeRelativePath(value, fallback) {
+  const raw = String(value || fallback || "").trim().replace(/\\/g, "/")
+  if (raw.startsWith("/") || /^[a-zA-Z]:/.test(raw)) {
+    return fallback
+  }
+  const normalized = path.posix.normalize(raw)
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+    return fallback
+  }
+  return normalized
+}
+
+function isInside(candidate, parent) {
+  const relative = path.relative(path.resolve(parent), path.resolve(candidate))
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+function normalizeNoteConfig(config = {}) {
+  const params = config && typeof config === "object" ? config : {}
+  return {
+    path: normalizeRelativePath(params.path, RESULT_RELATIVE_DIR),
+    content: normalizeRelativePath(params.content, ""),
+    ready: normalizeRelativePath(params.ready, METADATA_FILENAME),
+    description: typeof params.description === "string" ? params.description.trim() : "",
+    publish: clonePlainObject(params.publish)
+  }
+}
+
+async function findMetadataFiles(rootDir, filename) {
+  const root = path.resolve(rootDir)
+  const stats = await fs.promises.stat(root).catch(() => null)
+  if (!stats || !stats.isDirectory()) {
+    return []
+  }
+  const target = String(filename || METADATA_FILENAME)
+  const results = []
+  const visit = async (dir) => {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true }).catch(() => null)
+    if (!entries) return
+    for (const entry of entries) {
+      const fullPath = path.resolve(dir, entry.name)
+      if (entry.isDirectory()) {
+        await visit(fullPath)
+      } else if (entry.isFile() && entry.name === target) {
+        results.push(fullPath)
+      }
+    }
+  }
+  await visit(root)
+  return results
+}
+
+function createNoteService({ kernel, taskWorkspaceLinks } = {}) {
+  if (!kernel) {
+    throw new Error("kernel is required")
+  }
+
+  const resultsByBundle = new Map()
+
+  async function readMarkdown(notePath, stats) {
+    const noteStats = stats || await fs.promises.stat(notePath)
+    if (noteStats.size > MAX_MARKDOWN_BYTES) {
+      throw new Error(`note markdown is too large (${noteStats.size} bytes)`)
+    }
+    return fs.promises.readFile(notePath, "utf8")
+  }
+
+  async function readNoteMetadata(metadataPath) {
+    if (path.extname(metadataPath).toLowerCase() !== ".json") {
+      return {}
+    }
+    const raw = await fs.promises.readFile(metadataPath, "utf8")
+    return parseNoteMetadata(raw)
+  }
+
+  async function inspectNoteBundle({ taskId, ref, cwd, note, bundlePath, metadataPath } = {}) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null
+    }
+    const workspacePath = path.resolve(cwd.trim())
+    const noteConfig = normalizeNoteConfig(note)
+    const rootDir = path.resolve(workspacePath, noteConfig.path)
+    const resultDir = path.resolve(bundlePath || rootDir)
+    const readyPath = path.resolve(metadataPath || path.resolve(resultDir, noteConfig.ready))
+    const readyStats = await fs.promises.stat(readyPath).catch(() => null)
+    if (!readyStats || !readyStats.isFile()) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+    let metadata = {}
+    try {
+      metadata = await readNoteMetadata(readyPath)
+    } catch (_) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+
+    const contentPath = normalizeRelativePath(metadata.content || noteConfig.content, NOTE_FILENAME)
+    const notePath = path.resolve(resultDir, contentPath)
+    const noteStats = await fs.promises.stat(notePath).catch(() => null)
+    if (!noteStats || !noteStats.isFile()) {
+      resultsByBundle.delete(resultDir)
+      return null
+    }
+
+    const markdown = await readMarkdown(notePath, noteStats)
+    const workspaceName = path.basename(workspacePath)
+    const bundleName = path.basename(resultDir)
+    const media = await describeMediaRefs(markdown, resultDir)
+    const updatedAtMs = Math.max(readyStats.mtimeMs || 0, noteStats.mtimeMs || 0)
+    const id = createHash(`${workspacePath}|${resultDir}|${notePath}|${readyPath}`)
+    const previous = resultsByBundle.get(resultDir) || null
+    const publish = noteConfig.publish || (previous && previous.publish) || null
+    const description = noteConfig.description || (previous && previous.description) || ""
+    const mediaRevision = media
+      .map((item) => `${item.ref}:${item.exists ? item.bytes : "missing"}:${item.mtimeMs || 0}`)
+      .join("|")
+    const revision = createHash(`${noteStats.size}|${noteStats.mtimeMs}|${readyStats.size}|${readyStats.mtimeMs}|${mediaRevision}`)
+    const result = {
+      id,
+      revision,
+      taskId,
+      ref,
+      cwd: workspacePath,
+      workspaceName,
+      bundleName,
+      title: metadata.title || extractTitle(markdown, bundleName || workspaceName),
+      markdown,
+      excerpt: buildExcerpt(markdown),
+      resultDir,
+      watchRoot: rootDir,
+      notePath,
+      contentPath: notePath,
+      readyPath,
+      metadataPath: readyPath,
+      metadata,
+      publish,
+      description,
+      noteBytes: noteStats.size,
+      media: media.map((item, index) => ({
+        index,
+        ref: item.ref,
+        path: item.path,
+        bytes: item.bytes,
+        mtimeMs: item.mtimeMs,
+        exists: item.exists,
+        ext: path.extname(item.ref || "").toLowerCase()
+      })),
+      mediaCount: media.length,
+      missingMediaCount: media.filter((item) => !item.exists).length,
+      mediaBytes: media.reduce((total, item) => total + (Number.isFinite(item.bytes) ? item.bytes : 0), 0),
+      updatedAt: new Date(updatedAtMs || Date.now()).toISOString()
+    }
+    resultsByBundle.set(resultDir, result)
+    return result
+  }
+
+  async function inspectWorkspace({ taskId, ref, cwd, note } = {}) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null
+    }
+    const workspacePath = path.resolve(cwd.trim())
+    const noteConfig = normalizeNoteConfig(note)
+    const rootDir = path.resolve(workspacePath, noteConfig.path)
+    const metadataFiles = await findMetadataFiles(rootDir, noteConfig.ready)
+    const seen = new Set()
+    const results = []
+    for (const metadataPath of metadataFiles) {
+      const bundlePath = path.dirname(metadataPath)
+      const result = await inspectNoteBundle({
+        taskId,
+        ref,
+        cwd: workspacePath,
+        note: noteConfig,
+        bundlePath,
+        metadataPath
+      })
+      if (result) {
+        seen.add(result.resultDir)
+        results.push(result)
+      }
+    }
+    for (const [bundlePath, result] of Array.from(resultsByBundle.entries())) {
+      if (result && result.cwd === workspacePath && result.watchRoot === rootDir && !seen.has(bundlePath)) {
+        resultsByBundle.delete(bundlePath)
+      }
+    }
+    return results[0] || null
+  }
+
+  async function trackWorkspace({ taskId, ref, cwd } = {}) {
+    let resolvedCwd = cwd
+    if (!resolvedCwd && ref && taskWorkspaceLinks && typeof taskWorkspaceLinks.resolveWorkspaceRef === "function") {
+      resolvedCwd = taskWorkspaceLinks.resolveWorkspaceRef(ref)
+    }
+    if (!resolvedCwd) {
+      return null
+    }
+    return inspectWorkspace({ taskId, ref, cwd: resolvedCwd })
+  }
+
+  async function listPending(options = {}) {
+    const filterCwd = typeof options.cwd === "string" && options.cwd.trim()
+      ? path.resolve(options.cwd.trim())
+      : ""
+    return Array.from(resultsByBundle.values())
+      .filter((result) => !filterCwd || result.cwd === filterCwd)
+      .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+  }
+
+  async function getPendingById(id) {
+    const normalizedId = typeof id === "string" ? id.trim() : ""
+    if (!normalizedId) {
+      return null
+    }
+    return Array.from(resultsByBundle.values()).find((item) => item.id === normalizedId) || null
+  }
+
+  async function refreshPendingItem(item) {
+    if (!item || !item.cwd || !item.resultDir || !item.metadataPath) {
+      return null
+    }
+    return inspectNoteBundle({
+      taskId: item.taskId,
+      ref: item.ref,
+      cwd: item.cwd,
+      note: {
+        description: item.description,
+        publish: item.publish
+      },
+      bundlePath: item.resultDir,
+      metadataPath: item.metadataPath
+    })
+  }
+
+  async function savePendingById(id, options = {}) {
+    const item = await getPendingById(id)
+    if (!item) {
+      return null
+    }
+    const markdown = typeof options.markdown === "string" ? options.markdown : null
+    if (markdown === null) {
+      throw new Error("markdown is required")
+    }
+    if (Buffer.byteLength(markdown, "utf8") > MAX_MARKDOWN_BYTES) {
+      const error = new Error(`note markdown is too large; limit is ${MAX_MARKDOWN_BYTES} bytes`)
+      error.code = "NOTE_TOO_LARGE"
+      throw error
+    }
+
+    const current = await refreshPendingItem(item)
+    if (!current) {
+      return null
+    }
+    const expectedRevision = typeof options.revision === "string" ? options.revision.trim() : ""
+    if (expectedRevision && current.revision !== expectedRevision) {
+      const error = new Error("Note changed on disk. Reload it before saving.")
+      error.code = "NOTE_CONFLICT"
+      error.item = current
+      throw error
+    }
+
+    const notePath = path.resolve(current.notePath)
+    const resultDir = path.resolve(current.resultDir)
+    if (!isInside(notePath, resultDir)) {
+      const error = new Error("Note path is outside the note folder")
+      error.code = "NOTE_INVALID_PATH"
+      throw error
+    }
+
+    await fs.promises.writeFile(notePath, markdown, "utf8")
+    return refreshPendingItem(current)
+  }
+
+  async function start() {
+  }
+
+  async function stop() {
+  }
+
+  return {
+    RESULT_RELATIVE_DIR,
+    getPendingById,
+    inspectNoteBundle,
+    inspectWorkspace,
+    listPending,
+    savePendingById,
+    start,
+    stop,
+    trackWorkspace
+  }
+}
+
+module.exports = {
+  createNoteService
+}

package/server/features/{drafts → notes}/watcher.js

@@ -5,21 +5,19 @@ function isInside(candidate, parent) {
   return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
 }
 
-class DraftWatcher {
+class NoteWatcher {
   constructor(options = {}) {
-    this.drafts = options.drafts
+    this.notes = options.notes
   }
 
-  async ready(ctx, params = {}) {
-    if (!this.drafts || typeof this.drafts.inspectWorkspace !== "function") {
-      throw new Error("draft service is unavailable")
+  async watch(ctx, params = {}) {
+    if (!this.notes || typeof this.notes.inspectWorkspace !== "function") {
+      throw new Error("note service is unavailable")
     }
 
-    const draftDir = ctx.resolve(params.path || ".pinokio/draft")
-    const draftConfig = {
-      path: params.path || ".pinokio/draft",
-      content: params.content,
-      ready: params.ready,
+    const noteDir = ctx.resolve(params.path || ".pinokio/notes")
+    const noteConfig = {
+      path: params.path || ".pinokio/notes",
       description: params.description,
       publish: params.publish
     }
@@ -28,7 +26,7 @@ class DraftWatcher {
 
     const inspect = async () => {
       if (disposed) return
-      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig })
+      await this.notes.inspectWorkspace({ cwd: ctx.cwd, note: noteConfig })
     }
 
     const scheduleInspect = () => {
@@ -37,7 +35,7 @@ class DraftWatcher {
       timer = setTimeout(() => {
         timer = null
         inspect().catch((error) => {
-          console.warn("[drafts] failed to inspect workspace", error && error.message ? error.message : error)
+          console.warn("[notes] failed to inspect workspace", error && error.message ? error.message : error)
         })
       }, 250)
     }
@@ -46,12 +44,12 @@ class DraftWatcher {
     const stopPoll = ctx.poll(params.interval || 1500, inspect, {
       immediate: false,
       onError: (error) => {
-        console.warn("[drafts] poll failed", error && error.message ? error.message : error)
+        console.warn("[notes] poll failed", error && error.message ? error.message : error)
       }
     })
     const unsubscribe = await ctx.watch.fs(ctx.cwd, (events) => {
       if (!Array.isArray(events)) return
-      if (events.some((event) => event && event.path && isInside(path.resolve(event.path), draftDir))) {
+      if (events.some((event) => event && event.path && isInside(path.resolve(event.path), noteDir))) {
         scheduleInspect()
       }
     })
@@ -61,7 +59,7 @@ class DraftWatcher {
         clearTimeout(timer)
         timer = null
       }
-      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig }).catch(() => {})
+      await this.notes.inspectWorkspace({ cwd: ctx.cwd, note: noteConfig }).catch(() => {})
       disposed = true
       if (typeof stopPoll === "function") {
         await stopPoll()
@@ -73,4 +71,4 @@ class DraftWatcher {
   }
 }
 
-module.exports = DraftWatcher
+module.exports = NoteWatcher