pinokiod 7.2.7 → 7.2.9

package/kernel/watch/index.js

@@ -0,0 +1,158 @@
+const path = require("path")
+const WatchContext = require("./context")
+
+class WatchManager {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.handlers = new Map()
+    this.sessions = new Map()
+  }
+
+  registerHandler(name, handler) {
+    const normalized = typeof name === "string" ? name.trim() : ""
+    if (!normalized) {
+      throw new Error("watch handler name is required")
+    }
+    this.handlers.set(normalized, handler)
+  }
+
+  hasHandler(script, handlerName) {
+    const watches = script && Array.isArray(script.watch) ? script.watch : []
+    return watches.some((watch) => watch && watch.handler === handlerName)
+  }
+
+  renderDeclaration(raw, memory) {
+    let rendered = raw
+    let pass = 0
+    while (true) {
+      rendered = this.kernel.template.render(rendered, memory)
+      if (this.kernel.template.istemplate(rendered)) {
+        pass += 1
+        if (pass >= 4) break
+      } else {
+        break
+      }
+    }
+    return this.kernel.template.flatten(rendered)
+  }
+
+  buildMemory({ request, script, cwd, dirname, input, args }) {
+    return {
+      script: this.kernel.script,
+      input,
+      args,
+      cwd,
+      dirname,
+      uri: request.uri,
+      self: script,
+      kernel: this.kernel,
+      ...this.kernel.vars
+    }
+  }
+
+  async resolveExternalHandler(ctx, uri) {
+    const modpath = ctx.resolveModule(uri)
+    const loaded = await this.kernel.loader.load(modpath)
+    let handler = loaded && loaded.resolved
+    if (typeof handler === "function") {
+      handler = new handler()
+    }
+    return handler
+  }
+
+  async startForScript(options = {}) {
+    const script = options.script
+    const declarations = script && Array.isArray(script.watch) ? script.watch : []
+    if (declarations.length === 0) {
+      return
+    }
+
+    const id = options.id
+    if (!id) {
+      return
+    }
+    await this.stop(id)
+
+    const input = options.input || {}
+    const args = options.args || input
+    const cwd = path.resolve(options.cwd)
+    const dirname = path.resolve(options.dirname || options.cwd)
+    const memory = this.buildMemory({
+      request: options.request || {},
+      script,
+      cwd,
+      dirname,
+      input,
+      args
+    })
+    const disposers = []
+
+    for (const rawDeclaration of declarations) {
+      if (!rawDeclaration || typeof rawDeclaration !== "object") {
+        continue
+      }
+      try {
+        const declaration = this.renderDeclaration(rawDeclaration, memory)
+        const ctx = new WatchContext({
+          kernel: this.kernel,
+          manager: this,
+          id,
+          cwd,
+          dirname,
+          request: options.request,
+          script,
+          declaration,
+          input,
+          args
+        })
+        const methodName = typeof declaration.method === "string" ? declaration.method.trim() : ""
+        let handler = null
+        if (declaration.handler) {
+          handler = this.handlers.get(String(declaration.handler).trim())
+        } else if (declaration.uri) {
+          handler = await this.resolveExternalHandler(ctx, declaration.uri)
+        }
+        if (!handler || !methodName || typeof handler[methodName] !== "function") {
+          console.warn("[watch] handler not found", declaration)
+          continue
+        }
+        const cleanup = await handler[methodName](ctx, declaration.params || {})
+        if (cleanup) {
+          disposers.push(cleanup)
+        }
+      } catch (error) {
+        console.warn("[watch] failed to start", error && error.message ? error.message : error)
+      }
+    }
+
+    if (disposers.length > 0) {
+      this.sessions.set(id, disposers)
+    }
+  }
+
+  async stop(id) {
+    const normalized = typeof id === "string" ? id : ""
+    if (!normalized || !this.sessions.has(normalized)) {
+      return
+    }
+    const disposers = this.sessions.get(normalized) || []
+    this.sessions.delete(normalized)
+    for (const disposer of disposers.reverse()) {
+      try {
+        if (typeof disposer === "function") {
+          await disposer()
+        } else if (disposer && typeof disposer.stop === "function") {
+          await disposer.stop()
+        } else if (disposer && typeof disposer.dispose === "function") {
+          await disposer.dispose()
+        } else if (disposer && typeof disposer.unsubscribe === "function") {
+          await disposer.unsubscribe()
+        }
+      } catch (error) {
+        console.warn("[watch] cleanup failed", error && error.message ? error.message : error)
+      }
+    }
+  }
+}
+
+module.exports = WatchManager

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "7.2.7",
+  "version": "7.2.9",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/features/drafts/index.js

@@ -0,0 +1,41 @@
+const { createDraftService } = require("./service")
+const registerDraftRoutes = require("./routes")
+const DraftWatcher = require("./watcher")
+
+function createDraftFeature(options = {}) {
+  const { app, kernel } = options
+  if (!app) {
+    throw new Error("app is required")
+  }
+  if (!kernel) {
+    throw new Error("kernel is required")
+  }
+
+  const service = createDraftService({
+    kernel,
+    taskWorkspaceLinks: options.taskWorkspaceLinks
+  })
+
+  registerDraftRoutes(app, {
+    ...options,
+    drafts: service
+  })
+
+  if (kernel.watch && typeof kernel.watch.registerHandler === "function") {
+    kernel.watch.registerHandler("draft", new DraftWatcher({ drafts: service }))
+  }
+
+  return {
+    service,
+    async start() {
+      await service.start()
+    },
+    async stop() {
+      await service.stop()
+    }
+  }
+}
+
+module.exports = {
+  createDraftFeature
+}

package/server/features/drafts/parser.js

@@ -0,0 +1,169 @@
+const fs = require("fs")
+const path = require("path")
+
+const RESULT_RELATIVE_DIR = path.join(".pinokio", "draft")
+const POST_FILENAME = "post.md"
+const METADATA_FILENAME = "pinokio.json"
+const DEFAULT_READY_FILENAME = METADATA_FILENAME
+const PREVIEW_CHARS = 1200
+const MEDIA_EXTENSIONS = new Set([
+  ".apng",
+  ".avif",
+  ".gif",
+  ".jpeg",
+  ".jpg",
+  ".m4a",
+  ".mp3",
+  ".mp4",
+  ".ogg",
+  ".png",
+  ".svg",
+  ".wav",
+  ".webm",
+  ".webp"
+])
+
+function normalizeWhitespace(value) {
+  return String(value || "").replace(/\s+/g, " ").trim()
+}
+
+function extractTitle(markdown, workspaceName) {
+  const lines = String(markdown || "").split(/\r?\n/)
+  for (const line of lines) {
+    const match = line.match(/^#\s+(.+?)\s*#*\s*$/)
+    if (match && match[1]) {
+      return normalizeWhitespace(match[1]).slice(0, 140) || "Draft"
+    }
+  }
+  return workspaceName ? `Draft for ${workspaceName}` : "Draft"
+}
+
+function normalizeTitle(value) {
+  return normalizeWhitespace(value).slice(0, 160)
+}
+
+function parseDraftMetadata(raw) {
+  const parsed = JSON.parse(String(raw || ""))
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {}
+  }
+  const metadata = { ...parsed }
+  if (typeof metadata.title === "string") {
+    metadata.title = normalizeTitle(metadata.title)
+  } else {
+    delete metadata.title
+  }
+  return metadata
+}
+
+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 = normalizeWhitespace(match[1]).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() }
+}
+
+function buildExcerpt(markdown) {
+  const stripped = String(markdown || "")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/!\[[^\]]*]\([^)]+\)/g, " ")
+    .replace(/\[[^\]]+]\([^)]+\)/g, (match) => {
+      const label = match.match(/^\[([^\]]+)]/)
+      return label && label[1] ? ` ${label[1]} ` : " "
+    })
+    .replace(/^#+\s+/gm, "")
+    .replace(/[*_`>#-]/g, " ")
+  return normalizeWhitespace(stripped).slice(0, PREVIEW_CHARS)
+}
+
+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
+}
+
+async function describeMediaRefs(markdown, baseDir, options = {}) {
+  const refs = collectMarkdownRefs(markdown)
+  const media = []
+  for (const ref of refs) {
+    const ext = path.extname(ref).toLowerCase()
+    if (options.mediaOnly !== false && !MEDIA_EXTENSIONS.has(ext)) {
+      continue
+    }
+    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)
+    media.push({
+      ref,
+      path: filePath,
+      bytes: stats && stats.isFile() ? stats.size : 0,
+      mtimeMs: stats && stats.isFile() ? stats.mtimeMs : 0,
+      exists: Boolean(stats && stats.isFile())
+    })
+  }
+  return media
+}
+
+module.exports = {
+  METADATA_FILENAME,
+  DEFAULT_READY_FILENAME,
+  RESULT_RELATIVE_DIR,
+  POST_FILENAME,
+  buildExcerpt,
+  collectMarkdownRefs,
+  describeMediaRefs,
+  extractTitle,
+  extractTitleAndBody,
+  normalizeMarkdownRef,
+  normalizeTitle,
+  parseDraftMetadata
+}