pinokiod 7.2.8 → 7.2.9

package/server/{routes/draft_import.js → features/drafts/registry_import.js}

@@ -4,6 +4,11 @@ const path = require("path")
 const axios = require("axios")
 const FormData = require("form-data")
 const mime = require("mime-types")
+const {
+  describeMediaRefs,
+  extractTitleAndBody,
+  normalizeTitle
+} = require("./parser")
 
 const DEFAULT_MAX_FILES = 10
 const DEFAULT_MAX_FILE_BYTES = 25 * 1024 * 1024
@@ -77,7 +82,7 @@ function renderImportLauncher(res, { authorizeUrl, draftId, registryOrigin, auto
     }
 
     function openRegistry() {
-      registryWindow = window.open(authorizeUrl, "pinokioRegistryDraftImport", "popup,width=760,height=820");
+      registryWindow = window.open(authorizeUrl, "_blank");
       if (!registryWindow) {
         setStatus("The registry window was blocked. Click Open registry to continue.");
       } else {
@@ -145,65 +150,6 @@ function requestOrigin(req) {
   return `${req.protocol || "http"}://${host}`
 }
 
-function isExternalRef(value) {
-  return /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(value)
-}
-
-function normalizeMarkdownRef(value) {
-  const raw = String(value || "").trim().replace(/^<|>$/g, "")
-  if (!raw || raw.includes("\0") || isExternalRef(raw) || path.isAbsolute(raw)) {
-    return ""
-  }
-  const withoutHash = raw.split("#")[0]
-  const withoutQuery = withoutHash.split("?")[0]
-  if (!withoutQuery) {
-    return ""
-  }
-  let decoded = withoutQuery
-  try {
-    decoded = decodeURIComponent(withoutQuery)
-  } catch (_) {
-  }
-  const normalized = path.posix.normalize(decoded.replace(/\\/g, "/"))
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
-    return ""
-  }
-  return normalized
-}
-
-function collectMarkdownRefs(markdown) {
-  const refs = []
-  const seen = new Set()
-  const patterns = [
-    /!\[[^\]]*]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g,
-    /\[(?:video|audio|media|image|screenshot|file|asset)[^\]]*]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/gi,
-    /\[[^\]]+]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g
-  ]
-  for (const pattern of patterns) {
-    let match = null
-    while ((match = pattern.exec(markdown))) {
-      const ref = normalizeMarkdownRef(match[1])
-      if (!ref || seen.has(ref)) continue
-      seen.add(ref)
-      refs.push(ref)
-    }
-  }
-  return refs
-}
-
-function extractTitleAndBody(markdown, fallbackTitle) {
-  const lines = String(markdown || "").split(/\r?\n/)
-  for (let i = 0; i < lines.length; i += 1) {
-    const match = lines[i].match(/^#\s+(.+?)\s*#*\s*$/)
-    if (!match || !match[1]) continue
-    const title = match[1].replace(/\s+/g, " ").trim().slice(0, 160)
-    const bodyLines = [...lines.slice(0, i), ...lines.slice(i + 1)]
-    while (bodyLines.length && !bodyLines[0].trim()) bodyLines.shift()
-    return { title: title || fallbackTitle, body: bodyLines.join("\n").trim() }
-  }
-  return { title: fallbackTitle, body: String(markdown || "").trim() }
-}
-
 async function findDraftById(drafts, id) {
   const normalized = String(id || "").trim()
   if (!normalized) return null
@@ -211,32 +157,40 @@ async function findDraftById(drafts, id) {
   return (items || []).find((item) => item && item.id === normalized) || null
 }
 
-async function describeMedia(markdown, baseDir) {
-  const refs = collectMarkdownRefs(markdown)
-  const media = []
-  for (const ref of refs) {
-    const filePath = path.resolve(baseDir, ref)
-    const relative = path.relative(baseDir, filePath)
-    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) continue
-    const stats = await fs.promises.stat(filePath).catch(() => null)
-    if (!stats || !stats.isFile()) {
-      media.push({ ref, path: filePath, exists: false, bytes: 0 })
-      continue
-    }
-    media.push({ ref, path: filePath, exists: true, bytes: stats.size })
-  }
-  return media
+function isRegistryPostPublish(publish) {
+  if (!publish || typeof publish !== "object") return false
+  const target = String(publish.target || "").trim().toLowerCase()
+  const type = String(publish.type || "post").trim().toLowerCase()
+  return target === "registry" && type === "post"
+}
+
+function normalizeParent(parent) {
+  if (!parent || typeof parent !== "object" || Array.isArray(parent)) return null
+  const type = String(parent.type || "").trim().toLowerCase()
+  const url = String(parent.url || parent.repoUrl || "").trim()
+  if (type !== "app" || !url) return null
+  return { type: "app", url }
 }
 
 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 { title, body } = extractTitleAndBody(markdown, titleFallback)
-  const media = await describeMedia(markdown, resultDir)
+  const extracted = extractTitleAndBody(markdown, titleFallback)
+  const metadataTitle = item.metadata && typeof item.metadata.title === "string"
+    ? normalizeTitle(item.metadata.title)
+    : ""
+  const title = metadataTitle || extracted.title
+  const body = metadataTitle && extracted.title && normalizeTitle(extracted.title) === metadataTitle
+    ? extracted.body
+    : (!metadataTitle ? extracted.body : String(markdown || "").trim())
+  const publish = item.publish && typeof item.publish === "object" ? item.publish : null
+  const media = await describeMediaRefs(markdown, resultDir, { mediaOnly: false })
   return {
     title,
     body,
+    publish,
+    parent: normalizeParent(publish && publish.parent),
     appSlug: String(query.app || "").trim(),
     media
   }
@@ -248,6 +202,9 @@ function preflightBundle(bundle, options = {}) {
   if (!bundle.title) {
     return "Draft title is missing."
   }
+  if (!isRegistryPostPublish(bundle.publish)) {
+    return "This draft is not configured for registry publishing."
+  }
   if (bundle.media.length > maxFiles) {
     return `Draft has ${bundle.media.length} media files. The registry limit is ${maxFiles}.`
   }
@@ -268,6 +225,7 @@ async function uploadBundle(registryBase, token, bundle) {
     title: bundle.title,
     body: bundle.body,
     app: bundle.appSlug || "",
+    parent: bundle.parent || null,
     media: bundle.media.map((item) => ({ path: item.ref }))
   })
   form.append("metadata_b64", Buffer.from(metadata, "utf8").toString("base64"))

package/server/features/drafts/routes.js

@@ -0,0 +1,68 @@
+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 registerDraftRoutes(app, options = {}) {
+  const drafts = options.drafts
+  if (!drafts) {
+    throw new Error("drafts is required")
+  }
+
+  const router = express.Router()
+  router.get("/drafts", asyncHandler(async (req, res) => {
+    const cwd = typeof req.query.cwd === "string" ? req.query.cwd : ""
+    const items = await drafts.listPending({ cwd })
+    res.json({
+      ok: true,
+      items
+    })
+  }))
+
+  router.post("/drafts/:id/dismiss", asyncHandler(async (req, res) => {
+    const ok = await drafts.dismiss(req.params.id, req.body && req.body.revision)
+    res.json({ ok })
+  }))
+
+  router.get("/drafts/:id/media/:index", asyncHandler(async (req, res) => {
+    const item = typeof drafts.getPendingById === "function"
+      ? await drafts.getPendingById(req.params.id)
+      : null
+    if (!item) {
+      res.status(404).send("Draft 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 draft")
+      return
+    }
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(filePath)
+  }))
+
+  router.get("/drafts.js", (req, res) => {
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(path.resolve(__dirname, "public", "drafts.js"))
+  })
+
+  app.use(router)
+  registerDraftImportRoutes(app, options)
+}
+
+module.exports = registerDraftRoutes

package/server/features/drafts/service.js

@@ -0,0 +1,261 @@
+const fs = require("fs")
+const path = require("path")
+const crypto = require("crypto")
+const {
+  RESULT_RELATIVE_DIR,
+  POST_FILENAME,
+  DEFAULT_READY_FILENAME,
+  buildExcerpt,
+  describeMediaRefs,
+  extractTitle,
+  parseDraftMetadata
+} = require("./parser")
+
+const STATE_FILENAME = "drafts.json"
+const MAX_PREVIEW_BYTES = 256 * 1024
+
+function createHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 24)
+}
+
+function dismissalKey(id, revision) {
+  const normalizedId = typeof id === "string" ? id.trim() : ""
+  const normalizedRevision = typeof revision === "string" ? revision.trim() : ""
+  return normalizedRevision ? `${normalizedId}:${normalizedRevision}` : normalizedId
+}
+
+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 normalizeDraftConfig(config = {}) {
+  const params = config && typeof config === "object" ? config : {}
+  return {
+    path: normalizeRelativePath(params.path, RESULT_RELATIVE_DIR),
+    content: normalizeRelativePath(params.content || params.post, POST_FILENAME),
+    ready: normalizeRelativePath(params.ready, DEFAULT_READY_FILENAME),
+    description: typeof params.description === "string" ? params.description.trim() : "",
+    publish: clonePlainObject(params.publish)
+  }
+}
+
+function createDraftService({ kernel, taskWorkspaceLinks } = {}) {
+  if (!kernel) {
+    throw new Error("kernel is required")
+  }
+
+  const statePath = () => path.resolve(kernel.path("tasks"), STATE_FILENAME)
+  const resultsByWorkspace = new Map()
+  const dismissedIds = new Set()
+  let started = false
+  let stateLoaded = false
+
+  async function ensureStateLoaded() {
+    if (stateLoaded) return
+    stateLoaded = true
+    try {
+      const raw = await fs.promises.readFile(statePath(), "utf8")
+      const parsed = JSON.parse(raw)
+      if (parsed && Array.isArray(parsed.dismissed)) {
+        parsed.dismissed.forEach((id) => {
+          if (typeof id === "string" && id.trim()) {
+            dismissedIds.add(id.trim())
+          }
+        })
+      }
+    } catch (_) {
+    }
+  }
+
+  async function saveState() {
+    await fs.promises.mkdir(path.dirname(statePath()), { recursive: true })
+    const payload = {
+      version: 1,
+      dismissed: Array.from(dismissedIds).slice(-500)
+    }
+    await fs.promises.writeFile(statePath(), JSON.stringify(payload, null, 2))
+  }
+
+  async function readMarkdownPreview(postPath) {
+    const handle = await fs.promises.open(postPath, "r")
+    try {
+      const buffer = Buffer.alloc(MAX_PREVIEW_BYTES)
+      const read = await handle.read(buffer, 0, MAX_PREVIEW_BYTES, 0)
+      return buffer.slice(0, read.bytesRead).toString("utf8")
+    } finally {
+      await handle.close().catch(() => {})
+    }
+  }
+
+  async function readDraftMetadata(metadataPath) {
+    if (path.extname(metadataPath).toLowerCase() !== ".json") {
+      return {}
+    }
+    const raw = await fs.promises.readFile(metadataPath, "utf8")
+    return parseDraftMetadata(raw)
+  }
+
+  async function inspectWorkspace({ taskId, ref, cwd, draft } = {}) {
+    await ensureStateLoaded()
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null
+    }
+    const workspacePath = path.resolve(cwd.trim())
+    const draftConfig = normalizeDraftConfig(draft)
+    const resultDir = path.resolve(workspacePath, draftConfig.path)
+    const readyPath = path.resolve(resultDir, draftConfig.ready)
+    const postPath = path.resolve(resultDir, draftConfig.content)
+    const readyStats = await fs.promises.stat(readyPath).catch(() => null)
+    const postStats = await fs.promises.stat(postPath).catch(() => null)
+    if (!readyStats || !readyStats.isFile() || !postStats || !postStats.isFile()) {
+      resultsByWorkspace.delete(workspacePath)
+      return null
+    }
+    let metadata = {}
+    try {
+      metadata = await readDraftMetadata(readyPath)
+    } catch (_) {
+      resultsByWorkspace.delete(workspacePath)
+      return null
+    }
+
+    const markdown = await readMarkdownPreview(postPath)
+    const workspaceName = path.basename(workspacePath)
+    const media = await describeMediaRefs(markdown, resultDir)
+    const updatedAtMs = Math.max(readyStats.mtimeMs || 0, postStats.mtimeMs || 0)
+    const id = createHash(`${workspacePath}|${resultDir}|${postPath}|${readyPath}`)
+    const mediaRevision = media
+      .map((item) => `${item.ref}:${item.exists ? item.bytes : "missing"}:${item.mtimeMs || 0}`)
+      .join("|")
+    const revision = createHash(`${postStats.size}|${postStats.mtimeMs}|${readyStats.size}|${readyStats.mtimeMs}|${mediaRevision}`)
+    const result = {
+      id,
+      revision,
+      taskId,
+      ref,
+      cwd: workspacePath,
+      workspaceName,
+      title: metadata.title || extractTitle(markdown, workspaceName),
+      markdown,
+      excerpt: buildExcerpt(markdown),
+      resultDir,
+      postPath,
+      contentPath: postPath,
+      readyPath,
+      metadataPath: readyPath,
+      metadata,
+      publish: draftConfig.publish,
+      description: draftConfig.description,
+      postBytes: postStats.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()
+    }
+    resultsByWorkspace.set(workspacePath, result)
+    return result
+  }
+
+  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 = {}) {
+    await ensureStateLoaded()
+    const filterCwd = typeof options.cwd === "string" && options.cwd.trim()
+      ? path.resolve(options.cwd.trim())
+      : ""
+    return Array.from(resultsByWorkspace.values())
+      .filter((result) => !dismissedIds.has(dismissalKey(result.id, result.revision)) && !dismissedIds.has(result.id))
+      .filter((result) => !filterCwd || result.cwd === filterCwd)
+      .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+  }
+
+  async function getPendingById(id) {
+    await ensureStateLoaded()
+    const normalizedId = typeof id === "string" ? id.trim() : ""
+    if (!normalizedId) {
+      return null
+    }
+    const result = Array.from(resultsByWorkspace.values()).find((item) => item.id === normalizedId) || null
+    if (!result || dismissedIds.has(dismissalKey(result.id, result.revision)) || dismissedIds.has(result.id)) {
+      return null
+    }
+    return result
+  }
+
+  async function dismiss(id, revision) {
+    await ensureStateLoaded()
+    const normalizedId = typeof id === "string" ? id.trim() : ""
+    if (!normalizedId) {
+      return false
+    }
+    dismissedIds.add(dismissalKey(normalizedId, revision))
+    await saveState()
+    return true
+  }
+
+  async function refreshLinkedWorkspaces() {
+    await ensureStateLoaded()
+  }
+
+  async function start() {
+    if (started) return
+    started = true
+    await ensureStateLoaded()
+  }
+
+  async function stop() {
+  }
+
+  return {
+    RESULT_RELATIVE_DIR,
+    dismiss,
+    getPendingById,
+    inspectWorkspace,
+    listPending,
+    refreshLinkedWorkspaces,
+    start,
+    stop,
+    trackWorkspace
+  }
+}
+
+module.exports = {
+  createDraftService
+}

package/server/features/drafts/watcher.js

@@ -0,0 +1,76 @@
+const path = require("path")
+
+function isInside(candidate, parent) {
+  const relative = path.relative(parent, candidate)
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+class DraftWatcher {
+  constructor(options = {}) {
+    this.drafts = options.drafts
+  }
+
+  async ready(ctx, params = {}) {
+    if (!this.drafts || typeof this.drafts.inspectWorkspace !== "function") {
+      throw new Error("draft service is unavailable")
+    }
+
+    const draftDir = ctx.resolve(params.path || ".pinokio/draft")
+    const draftConfig = {
+      path: params.path || ".pinokio/draft",
+      content: params.content,
+      ready: params.ready,
+      description: params.description,
+      publish: params.publish
+    }
+    let timer = null
+    let disposed = false
+
+    const inspect = async () => {
+      if (disposed) return
+      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig })
+    }
+
+    const scheduleInspect = () => {
+      if (disposed) return
+      if (timer) clearTimeout(timer)
+      timer = setTimeout(() => {
+        timer = null
+        inspect().catch((error) => {
+          console.warn("[drafts] failed to inspect workspace", error && error.message ? error.message : error)
+        })
+      }, 250)
+    }
+
+    await inspect()
+    const stopPoll = ctx.poll(params.interval || 1500, inspect, {
+      immediate: false,
+      onError: (error) => {
+        console.warn("[drafts] 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))) {
+        scheduleInspect()
+      }
+    })
+
+    return async () => {
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+      await this.drafts.inspectWorkspace({ cwd: ctx.cwd, draft: draftConfig }).catch(() => {})
+      disposed = true
+      if (typeof stopPoll === "function") {
+        await stopPoll()
+      }
+      if (typeof unsubscribe === "function") {
+        await unsubscribe()
+      }
+    }
+  }
+}
+
+module.exports = DraftWatcher

package/server/features/index.js

@@ -0,0 +1,13 @@
+const { createDraftFeature } = require("./drafts")
+
+async function mountFeatures(options = {}) {
+  const drafts = createDraftFeature(options)
+  await drafts.start()
+  return {
+    drafts
+  }
+}
+
+module.exports = {
+  mountFeatures
+}