pinokiod 7.2.17 → 7.3.0

package/server/features/drafts/service.js

@@ -1,261 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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

package/server/lib/workspace_catalog.js

@@ -1,151 +0,0 @@
-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 }