pinokiod 7.2.8 → 7.2.10

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/environment.js

@@ -3,7 +3,139 @@ const portfinder = require('portfinder-cp')
 const os = require('os')
 const fs = require('fs')
 const Util = require('./util')
-const platform = os.platform()
+const TEMP_ENV_KEYS = ["TMP", "TEMP", "TMPDIR", "PIP_TMPDIR"]
+const CACHE_ENV_KEYS = ["UV_CACHE_DIR", "PIP_CACHE_DIR"]
+
+const envKey = (env, key) => {
+  return Object.keys(env).find((candidate) => candidate.toLowerCase() === key.toLowerCase())
+}
+
+const setEnv = (env, key, value) => {
+  for (const candidate of Object.keys(env)) {
+    if (candidate.toLowerCase() === key.toLowerCase() && candidate !== key) {
+      delete env[candidate]
+    }
+  }
+  env[key] = value
+}
+
+const normalizeEnvPath = (value, root) => {
+  if (typeof value !== "string") {
+    return null
+  }
+  const trimmed = value.trim()
+  if (!trimmed) {
+    return null
+  }
+  if (path.isAbsolute(trimmed)) {
+    return path.resolve(trimmed)
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith(".\\")) {
+    return path.resolve(root, trimmed)
+  }
+  return path.resolve(root, trimmed)
+}
+
+const isInsidePath = (candidate, root) => {
+  const rel = path.relative(path.resolve(root), path.resolve(candidate))
+  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel))
+}
+
+const canWriteDirectory = async (dirPath) => {
+  if (!dirPath) {
+    return false
+  }
+  const testDir = path.resolve(
+    dirPath,
+    `.pinokio-write-test-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  )
+  const testFile = path.resolve(testDir, "probe.tmp")
+  const renamedFile = path.resolve(testDir, "probe-renamed.tmp")
+  try {
+    await fs.promises.mkdir(testDir, { recursive: true })
+    await fs.promises.writeFile(testFile, "pinokio")
+    await fs.promises.appendFile(testFile, "-probe")
+    await fs.promises.rename(testFile, renamedFile)
+    await fs.promises.unlink(renamedFile)
+    await fs.promises.rmdir(testDir)
+    return true
+  } catch (error) {
+    await fs.promises.rm(testDir, { recursive: true, force: true }).catch(() => {})
+    return false
+  }
+}
+
+const ensureWritableDirectory = async (dirPath, options = {}) => {
+  if (!dirPath) {
+    return false
+  }
+  const repair = !!options.repair
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true })
+  } catch (error) {
+    if (!repair) {
+      return false
+    }
+    await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+    try {
+      await fs.promises.mkdir(dirPath, { recursive: true })
+    } catch (mkdirError) {
+      return false
+    }
+  }
+  if (await canWriteDirectory(dirPath)) {
+    return true
+  }
+  if (!repair) {
+    return false
+  }
+  await fs.promises.rm(dirPath, { recursive: true, force: true }).catch(() => {})
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true })
+  } catch (error) {
+    return false
+  }
+  return canWriteDirectory(dirPath)
+}
+
+const canRepairManagedCachePath = (candidate, cacheRoot) => {
+  const rel = path.relative(path.resolve(cacheRoot), path.resolve(candidate))
+  return !!rel && !rel.startsWith("..") && !path.isAbsolute(rel)
+}
+
+const managedCacheEnvDefaults = () => {
+  const defaults = {}
+  for (const key of TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)) {
+    defaults[key] = `./cache/${key}`
+  }
+  return defaults
+}
+
+const ensurePinokioCacheDirs = async (kernel) => {
+  if (!kernel || !kernel.homedir) {
+    return {}
+  }
+  const root = path.resolve(kernel.homedir)
+  const cacheRoot = path.resolve(root, "cache")
+  const envPath = path.resolve(root, "ENVIRONMENT")
+  const defaults = managedCacheEnvDefaults()
+  await Util.update_env(envPath, defaults)
+  const env = await get(root, kernel)
+
+  for (const key of TEMP_ENV_KEYS.concat(CACHE_ENV_KEYS)) {
+    const existingKey = envKey(env, key)
+    const dirPath = normalizeEnvPath(existingKey ? env[existingKey] : defaults[key], root)
+    const managedPath = path.resolve(cacheRoot, key)
+    const targetPath = dirPath && isInsidePath(dirPath, root) ? dirPath : managedPath
+    const repair = canRepairManagedCachePath(targetPath, cacheRoot)
+    if (!repair || !(await ensureWritableDirectory(targetPath, { repair: true }))) {
+      throw new Error(`Pinokio could not create a writable ${key} directory: ${targetPath}`)
+    }
+    setEnv(env, key, targetPath)
+  }
+
+  return env
+}
 const ENVS = async () => {
 //  const primary_port = 80
 //  const secondary_port = 42000
@@ -828,4 +960,4 @@ const init = async (options, kernel) => {
     env_path: current
   }
 }
-module.exports = { ENV, get, get2, init_folders, requirements, init, get_root  }
+module.exports = { ENV, get, get2, init_folders, ensurePinokioCacheDirs, requirements, init, get_root  }

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)
@@ -1051,6 +1053,7 @@ class Kernel {
 
         // 2. mkdir all the folders if not already created
         await Environment.init_folders(this.homedir, this)
+        await Environment.ensurePinokioCacheDirs(this)
 
         // if key.json doesn't exist, create an empty json file
         let ee = await this.exists(this.homedir, "key.json")

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