pinokiod 7.2.8 → 7.2.9

package/kernel/api/index.js

@@ -417,6 +417,12 @@ class Api {
         await this.process(script.on.stop) 
       }
     }
+    if (this.kernel.watch && typeof this.kernel.watch.stop === "function") {
+      if (req.params.id) {
+        await this.kernel.watch.stop(req.params.id)
+      }
+      await this.kernel.watch.stop(requestPath)
+    }
     // reset modules
     let modpath = this.resolvePath(cwd, req.params.uri)
     if (this.child_procs[modpath]) {
@@ -1456,6 +1462,25 @@ class Api {
     }
     return false
   }
+  async startWatchersForRequest(request, script, scriptDir, input) {
+    if (!this.kernel.watch || typeof this.kernel.watch.startForScript !== "function") {
+      return
+    }
+    const id = request.id || request.path
+    if (!id) {
+      return
+    }
+    const cwd = request.cwd || scriptDir
+    await this.kernel.watch.startForScript({
+      id,
+      request,
+      script,
+      cwd,
+      dirname: scriptDir,
+      input,
+      args: input
+    })
+  }
   createQueue(queue_id, concurrency) {
     this.queues[queue_id] = fastq.promise(async ({ request, rawrpc, input, step, total, cwd, args }) => {
       try {
@@ -1697,6 +1722,7 @@ class Api {
             }
 
             const initialPayload = typeof request.input === "undefined" ? {} : request.input
+            await this.startWatchersForRequest(request, script, cwd, initialPayload)
             this.queue(request, steps[0], initialPayload, 0, steps.length, cwd, initialPayload)
 
           } else {

package/kernel/index.js

@@ -40,6 +40,7 @@ const Git = require('./git')
 const Connect = require('./connect')
 const Favicon = require('./favicon')
 const AppLauncher = require('./app_launcher')
+const WatchManager = require('./watch')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
@@ -975,6 +976,7 @@ class Kernel {
     this.loader = new Loader()
     this.bin = new Bin(this)
     this.api = new Api(this)
+    this.watch = new WatchManager(this)
     this.python = new Python(this)
     this.shell = new Shells(this)
     this.appLauncher = new AppLauncher(this)

package/kernel/watch/context.js

@@ -0,0 +1,42 @@
+const path = require("path")
+const { watchFs } = require("./drivers/fs")
+const { poll } = require("./drivers/poll")
+
+class WatchContext {
+  constructor(options = {}) {
+    this.kernel = options.kernel
+    this.manager = options.manager
+    this.id = options.id
+    this.cwd = path.resolve(options.cwd)
+    this.dirname = path.resolve(options.dirname || options.cwd)
+    this.request = options.request
+    this.script = options.script
+    this.declaration = options.declaration
+    this.input = options.input || {}
+    this.args = options.args || this.input
+    this.watch = {
+      fs: (targetPath, callback, watchOptions = {}) => {
+        return watchFs(this.resolve(targetPath), callback, {
+          ...watchOptions,
+          onError: watchOptions.onError || ((error) => {
+            console.warn("[watch.fs]", error && error.message ? error.message : error)
+          })
+        })
+      }
+    }
+  }
+
+  resolve(targetPath) {
+    return this.kernel.api.resolvePath(this.cwd, String(targetPath || "."))
+  }
+
+  resolveModule(targetPath) {
+    return this.kernel.api.resolvePath(this.dirname, String(targetPath || "."))
+  }
+
+  poll(interval, callback, options = {}) {
+    return poll(interval, callback, options)
+  }
+}
+
+module.exports = WatchContext

package/kernel/watch/drivers/fs.js

@@ -0,0 +1,71 @@
+const fs = require("fs")
+const path = require("path")
+const ParcelWatcher = require("@parcel/watcher")
+
+const DEFAULT_IGNORE = [
+  "**/.git/**",
+  "**/node_modules/**",
+  "**/__pycache__/**",
+  "**/.venv/**",
+  "**/venv/**",
+  "**/env/**"
+]
+
+function isInside(candidate, parent) {
+  const relative = path.relative(parent, candidate)
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+async function nearestExistingDirectory(targetPath) {
+  let current = path.resolve(targetPath)
+  while (current && current !== path.dirname(current)) {
+    const stats = await fs.promises.stat(current).catch(() => null)
+    if (stats && stats.isDirectory()) {
+      return current
+    }
+    current = path.dirname(current)
+  }
+  return current || path.parse(path.resolve(targetPath)).root
+}
+
+async function watchFs(targetPath, callback, options = {}) {
+  const resolvedTarget = path.resolve(targetPath)
+  const targetStats = await fs.promises.stat(resolvedTarget).catch(() => null)
+  const watchRoot = targetStats && targetStats.isDirectory()
+    ? resolvedTarget
+    : await nearestExistingDirectory(resolvedTarget)
+  const filterToTarget = watchRoot !== resolvedTarget
+
+  const subscription = await ParcelWatcher.subscribe(
+    watchRoot,
+    (error, events) => {
+      if (error) {
+        if (typeof options.onError === "function") {
+          options.onError(error)
+        }
+        return
+      }
+      const normalizedEvents = Array.isArray(events) ? events : []
+      const filteredEvents = filterToTarget
+        ? normalizedEvents.filter((event) => event && event.path && isInside(path.resolve(event.path), resolvedTarget))
+        : normalizedEvents
+      if (filteredEvents.length === 0) {
+        return
+      }
+      callback(filteredEvents)
+    },
+    {
+      ignore: Array.isArray(options.ignore) ? options.ignore : DEFAULT_IGNORE
+    }
+  )
+
+  return async () => {
+    if (subscription && typeof subscription.unsubscribe === "function") {
+      await subscription.unsubscribe().catch(() => {})
+    }
+  }
+}
+
+module.exports = {
+  watchFs
+}

package/kernel/watch/drivers/poll.js

@@ -0,0 +1,33 @@
+function poll(interval, callback, options = {}) {
+  const delay = Math.max(100, Number(interval || options.interval || 1000))
+  let stopped = false
+  let running = false
+
+  const tick = async () => {
+    if (stopped || running) return
+    running = true
+    try {
+      await callback()
+    } catch (error) {
+      if (typeof options.onError === "function") {
+        options.onError(error)
+      }
+    } finally {
+      running = false
+    }
+  }
+
+  if (options.immediate !== false) {
+    setTimeout(tick, 0)
+  }
+  const timer = setInterval(tick, delay)
+
+  return async () => {
+    stopped = true
+    clearInterval(timer)
+  }
+}
+
+module.exports = {
+  poll
+}

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.8",
+  "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
+}