pinokiod 7.2.7 → 7.2.9

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
+}

package/server/index.js

@@ -28,6 +28,8 @@ const system = require('systeminformation')
 const serveIndex = require('./serveIndex')
 const registerFileRoutes = require('./routes/files')
 const registerAppRoutes = require('./routes/apps')
+const registerWorkspacesRoutes = require('./routes/workspaces')
+const { mountFeatures } = require('./features')
 const Git = require("../kernel/git")
 const TerminalApi = require('../kernel/api/terminal')
 
@@ -78,6 +80,8 @@ const { createDesktopEventRouter } = require("./lib/desktop_event_router")
 const { createInjectRouter, resolveInjectList } = require("./lib/inject_router")
 const { createTaskPackageService } = require("./lib/task_packages")
 const { createTaskWorkspaceLinkService } = require("./lib/task_workspace_links")
+const { createWorkspaceRuntimeService } = require("./lib/workspace_runtime")
+const { createWorkspaceCatalogService } = require("./lib/workspace_catalog")
 const { createContentValidationService } = require("./lib/content_validation")
 const { buildSecureRouterDebugSnapshot, createSecureRouterDebugStore } = require("./lib/secure_router_debug")
 const AppRegistryService = require("./lib/app_registry")
@@ -2865,11 +2869,19 @@ class Server {
           const protectionPreference = protectionAppId && this.appPreferences && typeof this.appPreferences.getPreference === "function"
             ? await this.appPreferences.getPreference(protectionAppId)
             : null
+          const draftWatchEnabled = this.kernel.watch && typeof this.kernel.watch.hasHandler === "function"
+            ? this.kernel.watch.hasHandler(resolved, "draft")
+            : false
+          const draftWatchCwd = draftWatchEnabled
+            ? (req.query.cwd || path.dirname(filepath))
+            : ""
           const result = {
             portal: this.portal,
             projectName: (pathComponents.length > 0 ? pathComponents[0] : ''),
             protection_app_id: protectionAppId,
             protection_enabled: protectionPreference ? protectionPreference.protection_enabled !== false : false,
+            draft_watch_enabled: draftWatchEnabled,
+            draft_watch_cwd: draftWatchCwd,
             kill_message,
             callback,
             callback_target,
@@ -8403,6 +8415,32 @@ class Server {
     const taskWorkspaceLinks = createTaskWorkspaceLinkService({
       kernel: this.kernel
     })
+    const workspaceRuntime = createWorkspaceRuntimeService({
+      kernel: this.kernel
+    })
+    this.workspaceRuntime = workspaceRuntime
+    const features = await mountFeatures({
+      app: this.app,
+      kernel: this.kernel,
+      taskWorkspaceLinks,
+      defaultRegistryUrl: DEFAULT_REGISTRY_URL
+    })
+    this.features = features
+    const drafts = features.drafts.service
+    this.drafts = drafts
+    const workspaceCatalog = createWorkspaceCatalogService({
+      kernel: this.kernel,
+      workspaceRuntime,
+      drafts
+    })
+    registerWorkspacesRoutes(this.app, {
+      workspaceCatalog,
+      composePeerAccessPayload: () => this.composePeerAccessPayload(),
+      getTheme: () => this.theme,
+      getPeers: () => this.getPeers(),
+      getCurrentHost: () => this.kernel.peer.host,
+      getPortal: () => this.portal
+    })
     const TASK_INPUT_NAME_PATTERN = /^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/
     const suggestTaskFolderName = async (rootDir, preferredName) => {
       const normalizedRoot = path.resolve(rootDir)
@@ -10073,7 +10111,8 @@ class Server {
         }
       }
 
-      const prompt = taskPackages.applyTemplateValues(task.template, filterFilledTaskInputValues(inputValues)).trim()
+      const filledInputValues = filterFilledTaskInputValues(inputValues)
+      const prompt = taskPackages.applyTemplateValues(task.template, filledInputValues).trim()
       if (!prompt) {
         await renderTaskLaunchPage(req, res, task, {
           selectedTool,
@@ -10194,6 +10233,9 @@ class Server {
       params.set("cwd", targetPath)
       params.set("chrome", "full")
       params.set("prompt", prompt)
+      if (filledInputValues.url) {
+        params.set("url", filledInputValues.url)
+      }
       res.redirect(`${pluginHref}?${params.toString()}`)
     })
     this.app.post("/task/start", handleTaskStartRequest)
@@ -10500,7 +10542,8 @@ class Server {
           return
         }
 
-        const prompt = taskPackages.applyTemplateValues(task.template, filterFilledTaskInputValues(inputValues)).trim()
+        const filledInputValues = filterFilledTaskInputValues(inputValues)
+        const prompt = taskPackages.applyTemplateValues(task.template, filledInputValues).trim()
         if (!prompt) {
           res.status(400).json({
             ok: false,
@@ -10600,6 +10643,9 @@ class Server {
         params.set("chrome", "full")
         params.set("session", createUniversalLauncherSessionId())
         params.set("prompt", prompt)
+        if (filledInputValues.url) {
+          params.set("url", filledInputValues.url)
+        }
 
         res.json({
           ok: true,
@@ -11851,11 +11897,14 @@ class Server {
         // but allow it when the request originates from the local machine
         if (payload.audience === 'device' && typeof payload.device_id === 'string' && payload.device_id) {
           try {
-            if (this.socket && typeof this.socket.isLocalDevice === 'function') {
-              payload.host = !!this.socket.isLocalDevice(payload.device_id)
-            } else {
-              payload.host = false
-            }
+            const remoteAddress = req.socket && req.socket.remoteAddress ? req.socket.remoteAddress : req.ip
+            const isLocalRequest = this.socket && typeof this.socket.isLocalAddress === 'function'
+              ? this.socket.isLocalAddress(remoteAddress)
+              : false
+            const isLocalDevice = this.socket && typeof this.socket.isLocalDevice === 'function'
+              ? this.socket.isLocalDevice(payload.device_id)
+              : false
+            payload.host = !!(isLocalRequest || isLocalDevice)
           } catch (_) {
             payload.host = false
           }

package/server/lib/workspace_catalog.js

@@ -0,0 +1,151 @@
+const fs = require("fs")
+const path = require("path")
+
+const SORT_MODES = new Set(["most_used", "last_opened", "az"])
+
+function normalizeSortMode(sort) {
+  if (SORT_MODES.has(sort)) return sort
+  return "most_used"
+}
+
+function normalizePathKey(filepath) {
+  const resolved = path.resolve(filepath).replace(/[\\/]+$/, "")
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved
+}
+
+function toRoutePath(filepath) {
+  const resolved = path.resolve(filepath).replace(/\\/g, "/")
+  const encoded = resolved
+    .split("/")
+    .map((segment, index) => {
+      if (index === 0 && segment === "") return ""
+      return encodeURIComponent(segment)
+    })
+    .join("/")
+  return encoded.startsWith("/") ? `/d${encoded}` : `/d/${encoded}`
+}
+
+function latestTimestamp(values) {
+  return values.reduce((latest, value) => {
+    if (!value) return latest
+    const timestamp = typeof value === "number" ? value : new Date(value).getTime()
+    return Number.isFinite(timestamp) && timestamp > latest ? timestamp : latest
+  }, 0)
+}
+
+function sortWorkspaces(items, sort) {
+  const mode = normalizeSortMode(sort)
+  const sorted = [...items]
+  sorted.sort((a, b) => {
+    if (mode === "az") {
+      return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+    }
+    if (mode === "last_opened") {
+      const delta = (b.lastOpenedAtMs || b.modifiedAtMs || 0) - (a.lastOpenedAtMs || a.modifiedAtMs || 0)
+      if (delta !== 0) return delta
+      return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+    }
+    const usageDelta = (b.usageCount || 0) - (a.usageCount || 0)
+    if (usageDelta !== 0) return usageDelta
+    return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+  })
+  return sorted
+}
+
+function newestDraft(drafts) {
+  return [...drafts].sort((a, b) => {
+    return (new Date(b.updatedAt || 0).getTime() || 0) - (new Date(a.updatedAt || 0).getTime() || 0)
+  })[0] || null
+}
+
+function createWorkspaceCatalogService({ kernel, workspaceRuntime, drafts }) {
+  async function list(options = {}) {
+    const sort = normalizeSortMode(options.sort)
+    const root = path.resolve(kernel.path("workspaces"))
+    const entries = await fs.promises.readdir(root, { withFileTypes: true }).catch(() => [])
+    const runtime = workspaceRuntime.list()
+    const liveByPath = new Map()
+
+    for (const group of runtime.workspaces || []) {
+      if (group.root !== "workspaces") continue
+      liveByPath.set(normalizePathKey(group.cwd), group)
+    }
+
+    const draftByPath = new Map()
+    const pendingDrafts = drafts ? await drafts.listPending({}).catch(() => []) : []
+    for (const draft of pendingDrafts) {
+      if (!draft.cwd) continue
+      const key = normalizePathKey(draft.cwd)
+      const list = draftByPath.get(key) || []
+      list.push(draft)
+      draftByPath.set(key, list)
+    }
+
+    const folders = entries.filter((entry) => entry.isDirectory())
+    const items = []
+
+    for (const entry of folders) {
+      const cwd = path.join(root, entry.name)
+      const stats = await fs.promises.stat(cwd).catch(() => null)
+      const key = normalizePathKey(cwd)
+      const live = liveByPath.get(key)
+      const shells = live?.shells || []
+      const scripts = live?.scripts || []
+      const workspaceDrafts = draftByPath.get(key) || []
+      const draft = newestDraft(workspaceDrafts)
+      const modifiedAtMs = stats?.mtimeMs || 0
+      const lastOpenedAtMs = latestTimestamp([
+        modifiedAtMs,
+        ...shells.map((shell) => shell.start_time),
+        ...workspaceDrafts.map((item) => item.updatedAt),
+      ])
+      const primaryShell = shells.length === 1 ? shells[0] : null
+      const primaryScript = scripts.length === 1 ? scripts[0] : null
+      const usageCount = shells.length + scripts.length
+
+      items.push({
+        name: entry.name,
+        cwd,
+        relpath: entry.name,
+        modifiedAt: modifiedAtMs ? new Date(modifiedAtMs).toISOString() : null,
+        modifiedAtMs,
+        lastOpenedAt: lastOpenedAtMs ? new Date(lastOpenedAtMs).toISOString() : null,
+        lastOpenedAtMs,
+        usageCount,
+        running: shells.length > 0 || scripts.length > 0,
+        counts: {
+          shells: shells.length,
+          scripts: scripts.length,
+          drafts: workspaceDrafts.length,
+        },
+        shells,
+        scripts,
+        draft,
+        draftReady: Boolean(draft),
+        primaryUrl: primaryScript?.url || primaryShell?.url || null,
+        launchUrl: toRoutePath(cwd),
+      })
+    }
+
+    const running = sortWorkspaces(items.filter((item) => item.running), sort)
+    const offline = sortWorkspaces(items.filter((item) => !item.running), sort)
+
+    return {
+      root,
+      sort,
+      running,
+      offline,
+      items: [...running, ...offline],
+      counts: {
+        total: items.length,
+        running: running.length,
+        offline: offline.length,
+        drafts: items.filter((item) => item.draftReady).length,
+      },
+    }
+  }
+
+  return { list, normalizeSortMode }
+}
+
+module.exports = { createWorkspaceCatalogService, normalizeSortMode }