pinokiod 7.2.7 → 7.2.8

package/server/lib/drafts.js

@@ -0,0 +1,376 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const ParcelWatcher = require("@parcel/watcher");
+
+const RESULT_RELATIVE_DIR = path.join(".pinokio", "draft");
+const POST_FILENAME = "post.md";
+const READY_FILENAME = "READY";
+const STATE_FILENAME = "drafts.json";
+const MAX_PREVIEW_BYTES = 256 * 1024;
+const PREVIEW_CHARS = 1200;
+const MEDIA_EXTENSIONS = new Set([
+  ".apng",
+  ".avif",
+  ".gif",
+  ".jpeg",
+  ".jpg",
+  ".m4a",
+  ".mp3",
+  ".mp4",
+  ".ogg",
+  ".png",
+  ".svg",
+  ".wav",
+  ".webm",
+  ".webp"
+]);
+
+function createHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 24);
+}
+
+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 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) {
+  const refs = collectMarkdownRefs(markdown);
+  const media = [];
+  for (const ref of refs) {
+    const ext = path.extname(ref).toLowerCase();
+    if (!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 : null,
+      exists: Boolean(stats && stats.isFile())
+    });
+  }
+  return media;
+}
+
+function isRelevantEvent(workspacePath, eventPath) {
+  const relative = path.relative(workspacePath, eventPath || "");
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return false;
+  }
+  const normalized = relative.split(path.sep).join("/");
+  return normalized === ".pinokio/draft"
+    || normalized.startsWith(".pinokio/draft/");
+}
+
+function createDraftService({ kernel, taskWorkspaceLinks }) {
+  if (!kernel) {
+    throw new Error("kernel is required");
+  }
+  if (!taskWorkspaceLinks) {
+    throw new Error("taskWorkspaceLinks is required");
+  }
+
+  const statePath = () => path.resolve(kernel.path("tasks"), STATE_FILENAME);
+  const resultsByWorkspace = new Map();
+  const watchersByWorkspace = 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 inspectWorkspace({ taskId, ref, cwd }) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return null;
+    }
+    const workspacePath = path.resolve(cwd.trim());
+    const resultDir = path.join(workspacePath, RESULT_RELATIVE_DIR);
+    const readyPath = path.join(resultDir, READY_FILENAME);
+    const postPath = path.join(resultDir, POST_FILENAME);
+    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;
+    }
+
+    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}|${postStats.size}|${postStats.mtimeMs}|${readyStats.mtimeMs}`);
+    const result = {
+      id,
+      taskId,
+      ref,
+      cwd: workspacePath,
+      workspaceName,
+      title: extractTitle(markdown, workspaceName),
+      excerpt: buildExcerpt(markdown),
+      postPath,
+      readyPath,
+      postBytes: postStats.size,
+      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;
+  }
+
+  function scheduleInspect(taskId, ref, cwd) {
+    setTimeout(() => {
+      inspectWorkspace({ taskId, ref, cwd }).catch((error) => {
+        console.warn("[drafts] failed to inspect workspace", error && error.message ? error.message : error);
+      });
+    }, 250);
+  }
+
+  async function ensureWatcher(taskId, ref, cwd) {
+    if (typeof cwd !== "string" || !cwd.trim()) {
+      return;
+    }
+    const workspacePath = path.resolve(cwd.trim());
+    if (watchersByWorkspace.has(workspacePath)) {
+      return;
+    }
+    const stats = await fs.promises.stat(workspacePath).catch(() => null);
+    if (!stats || !stats.isDirectory()) {
+      return;
+    }
+    try {
+      const subscription = await ParcelWatcher.subscribe(
+        workspacePath,
+        (error, events) => {
+          if (error) {
+            console.warn("[drafts] watcher error", error && error.message ? error.message : error);
+            return;
+          }
+          if (!Array.isArray(events) || !events.some((event) => isRelevantEvent(workspacePath, event && event.path))) {
+            return;
+          }
+          scheduleInspect(taskId, ref, workspacePath);
+        },
+        {
+          ignore: [
+            "**/.git/**",
+            "**/node_modules/**",
+            "**/__pycache__/**",
+            "**/.venv/**",
+            "**/venv/**",
+            "**/env/**"
+          ]
+        }
+      );
+      watchersByWorkspace.set(workspacePath, subscription);
+    } catch (error) {
+      console.warn("[drafts] failed to watch workspace", error && error.message ? error.message : error);
+    }
+  }
+
+  async function refreshLinkedWorkspaces() {
+    await ensureStateLoaded();
+    const registry = await taskWorkspaceLinks.readRegistry();
+    const seen = new Set();
+    const tasks = registry && registry.tasks && typeof registry.tasks === "object" ? registry.tasks : {};
+    for (const [taskId, entry] of Object.entries(tasks)) {
+      const workspaces = entry && Array.isArray(entry.workspaces) ? entry.workspaces : [];
+      for (const workspace of workspaces) {
+        const ref = workspace && typeof workspace.ref === "string" ? workspace.ref : "";
+        const cwd = taskWorkspaceLinks.resolveWorkspaceRef(ref);
+        if (!cwd) {
+          continue;
+        }
+        const workspacePath = path.resolve(cwd);
+        seen.add(workspacePath);
+        await ensureWatcher(taskId, ref, workspacePath);
+        await inspectWorkspace({ taskId, ref, cwd: workspacePath });
+      }
+    }
+    for (const workspacePath of Array.from(resultsByWorkspace.keys())) {
+      if (!seen.has(workspacePath)) {
+        resultsByWorkspace.delete(workspacePath);
+      }
+    }
+  }
+
+  async function start() {
+    if (started) {
+      return;
+    }
+    started = true;
+    await refreshLinkedWorkspaces();
+  }
+
+  async function trackWorkspace({ taskId, ref }) {
+    await ensureStateLoaded();
+    const cwd = taskWorkspaceLinks.resolveWorkspaceRef(ref);
+    if (!cwd) {
+      return null;
+    }
+    await ensureWatcher(taskId, ref, cwd);
+    return inspectWorkspace({ taskId, ref, cwd });
+  }
+
+  async function listPending(options = {}) {
+    await refreshLinkedWorkspaces();
+    const filterCwd = typeof options.cwd === "string" && options.cwd.trim()
+      ? path.resolve(options.cwd.trim())
+      : "";
+    return Array.from(resultsByWorkspace.values())
+      .filter((result) => !dismissedIds.has(result.id))
+      .filter((result) => !filterCwd || result.cwd === filterCwd)
+      .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+  }
+
+  async function dismiss(id) {
+    await ensureStateLoaded();
+    const normalizedId = typeof id === "string" ? id.trim() : "";
+    if (!normalizedId) {
+      return false;
+    }
+    dismissedIds.add(normalizedId);
+    await saveState();
+    return true;
+  }
+
+  async function stop() {
+    for (const subscription of watchersByWorkspace.values()) {
+      if (subscription && typeof subscription.unsubscribe === "function") {
+        await subscription.unsubscribe().catch(() => {});
+      }
+    }
+    watchersByWorkspace.clear();
+  }
+
+  return {
+    RESULT_RELATIVE_DIR,
+    dismiss,
+    inspectWorkspace,
+    listPending,
+    refreshLinkedWorkspaces,
+    start,
+    stop,
+    trackWorkspace
+  };
+}
+
+module.exports = {
+  createDraftService
+};

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 }