npm - pinokiod - Versions diffs - 7.2.16 → 7.2.18 - Mend

pinokiod 7.2.16 → 7.2.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/kernel/agent_instructions.js +166 -0
package/kernel/api/index.js +137 -12
package/kernel/bin/huggingface.js +1 -1
package/kernel/environment.js +23 -9
package/kernel/plugin_sources.js +57 -4
package/kernel/prototype.js +4 -0
package/kernel/shell.js +2 -0
package/kernel/watch/index.js +31 -4
package/package.json +1 -1
package/server/features/index.js +4 -4
package/server/features/{drafts → notes}/index.js +9 -9
package/server/features/{drafts → notes}/parser.js +12 -7
package/server/features/notes/public/notes.css +955 -0
package/server/features/notes/public/notes.js +1149 -0
package/server/features/{drafts → notes}/registry_import.js +59 -74
package/server/features/notes/routes.js +156 -0
package/server/features/notes/service.js +326 -0
package/server/features/{drafts → notes}/watcher.js +14 -16
package/server/index.js +61 -30
package/server/lib/content_validation.js +19 -8
package/server/lib/workspace_catalog.js +18 -18
package/server/public/task-launcher.css +11 -3
package/server/public/tasker.css +336 -0
package/server/public/tasker.js +407 -0
package/server/views/d.ejs +33 -2
package/server/views/partials/menu.ejs +1 -1
package/server/views/partials/workspace_row.ejs +11 -11
package/server/views/pre.ejs +1 -1
package/server/views/task_launch.ejs +10 -10
package/server/views/tasker.ejs +40 -0
package/server/views/terminal.ejs +15 -6
package/server/views/terminals.ejs +0 -1
package/server/views/workspaces.ejs +2 -1
package/system/plugin/antigravity/pinokio.js +2 -4
package/system/plugin/claude/pinokio.js +2 -4
package/system/plugin/claude-auto/pinokio.js +2 -4
package/system/plugin/claude-desktop/pinokio.js +2 -4
package/system/plugin/codex/pinokio.js +2 -4
package/system/plugin/codex-auto/pinokio.js +2 -4
package/system/plugin/codex-desktop/pinokio.js +2 -4
package/system/plugin/crush/pinokio.js +2 -4
package/system/plugin/cursor/pinokio.js +2 -4
package/system/plugin/gemini/pinokio.js +2 -4
package/system/plugin/gemini-auto/pinokio.js +2 -4
package/system/plugin/qwen/pinokio.js +2 -4
package/system/plugin/vscode/pinokio.js +2 -4
package/system/plugin/windsurf/pinokio.js +2 -4
package/test/plugin-sources.test.js +45 -0
package/server/features/drafts/public/drafts.js +0 -1569
package/server/features/drafts/routes.js +0 -68
package/server/features/drafts/service.js +0 -261

package/server/features/{drafts → notes}/registry_import.js RENAMED Viewed

@@ -45,7 +45,7 @@ function renderMessage(res, status, title, message) {
 </html>`)
 }
-function renderImportLauncher(res, { authorizeUrl, draftId, registryOrigin, autoOpen }) {
+function renderImportLauncher(res, { authorizeUrl, autoOpen }) {
   res.status(200).send(`<!doctype html>
 <html>
 <head>
@@ -63,68 +63,48 @@ function renderImportLauncher(res, { authorizeUrl, draftId, registryOrigin, auto
 <body>
   <div class="box">
     <h1>Import draft</h1>
-    <p id="status">${autoOpen ? "Opening the registry authorization window..." : "Click Open registry to authorize the import."}</p>
+    <p id="status">${autoOpen ? "Opening the registry authorization page in your browser..." : "Click Open registry to authorize the import."}</p>
     <button id="open" type="button">Open registry</button>
-    <div class="muted" style="margin-top:12px;">Keep this Pinokio window open until the registry draft editor opens.</div>
+    <div class="muted" style="margin-top:12px;">The registry will return to Pinokio after authorization.</div>
   </div>
   <script>
     window.__PINOKIO_DRAFT_IMPORT_VERSION = "metadata-b64";
     const authorizeUrl = ${JSON.stringify(authorizeUrl)};
-    const draftId = ${JSON.stringify(draftId)};
-    const registryOrigin = ${JSON.stringify(registryOrigin)};
     const autoOpen = ${JSON.stringify(Boolean(autoOpen))};
     const statusEl = document.getElementById("status");
     const openButton = document.getElementById("open");
-    let registryWindow = null;
     function setStatus(message) {
       statusEl.textContent = message;
     }
-    function openRegistry() {
-      registryWindow = window.open(authorizeUrl, "_blank");
-      if (!registryWindow) {
-        setStatus("The registry window was blocked. Click Open registry to continue.");
-      } else {
-        setStatus("Authorize the import in the registry window.");
-      }
-    }
-    async function completeImport(payload) {
-      setStatus("Uploading draft to the registry...");
-      const response = await fetch("/registry/draft-import/complete", {
+    async function openRegistry() {
+      setStatus("Opening registry in your browser...");
+      const response = await fetch("/pinokio/open", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          draft: draftId,
-          token: payload.token,
-          registry: payload.registry,
-          app: payload.app || ""
+          url: authorizeUrl,
+          surface: "browser"
         })
       });
-      const data = await response.json().catch(() => null);
-      if (!response.ok || !data || !data.editUrl) {
-        const detail = data && data.status ? " (" + data.status + ")" : "";
-        throw new Error(((data && data.error) || "Import failed.") + detail);
+      if (!response.ok) {
+        throw new Error("Unable to open registry.");
       }
-      try {
-        if (registryWindow && !registryWindow.closed) registryWindow.close();
-      } catch (_) {}
-      window.location.href = data.editUrl;
+      setStatus("Authorize the import in your browser.");
     }
-    window.addEventListener("message", (event) => {
-      if (event.origin !== registryOrigin) return;
-      const payload = event.data || {};
-      if (payload.type !== "pinokio:draft-import-token" || !payload.token || !payload.registry) return;
-      completeImport(payload).catch((error) => {
-        setStatus(error && error.message ? error.message : "Import failed.");
+    openButton.addEventListener("click", () => {
+      openRegistry().catch((error) => {
+        setStatus(error && error.message ? error.message : "Unable to open registry.");
       });
     });
-    openButton.addEventListener("click", openRegistry);
     if (autoOpen) {
-      window.setTimeout(openRegistry, 100);
+      window.setTimeout(() => {
+        openRegistry().catch((error) => {
+          setStatus(error && error.message ? error.message : "Unable to open registry.");
+        });
+      }, 100);
     }
   </script>
 </body>
@@ -150,10 +130,25 @@ function requestOrigin(req) {
   return `${req.protocol || "http"}://${host}`
 }
-async function findDraftById(drafts, id) {
+function buildDraftImportReturnUrl(req, item, bundle) {
+  const returnUrl = new URL("/registry/draft-import/callback", requestOrigin(req))
+  returnUrl.searchParams.set("draft", item.id)
+  if (bundle.appSlug) returnUrl.searchParams.set("app", bundle.appSlug)
+  return returnUrl.toString()
+}
+function buildAuthorizeUrl(req, registryBase, item, bundle) {
+  const authorizeUrl = new URL("/draft-import/authorize", registryBase)
+  authorizeUrl.searchParams.set("handoff", "callback")
+  authorizeUrl.searchParams.set("return", buildDraftImportReturnUrl(req, item, bundle))
+  if (bundle.appSlug) authorizeUrl.searchParams.set("app", bundle.appSlug)
+  return authorizeUrl
+}
+async function findNoteById(notes, id) {
   const normalized = String(id || "").trim()
   if (!normalized) return null
-  const items = await drafts.listPending({})
+  const items = await notes.listPending({})
   return (items || []).find((item) => item && item.id === normalized) || null
 }
@@ -173,9 +168,9 @@ function normalizeParent(parent) {
 }
 async function buildDraftBundle(item, query = {}) {
-  const markdown = await fs.promises.readFile(item.postPath, "utf8")
-  const resultDir = path.dirname(item.postPath)
-  const titleFallback = item.title || (item.workspaceName ? `Draft for ${item.workspaceName}` : "Draft")
+  const markdown = await fs.promises.readFile(item.notePath, "utf8")
+  const resultDir = path.dirname(item.notePath)
+  const titleFallback = item.title || (item.workspaceName ? `Note for ${item.workspaceName}` : "Note")
   const extracted = extractTitleAndBody(markdown, titleFallback)
   const metadataTitle = item.metadata && typeof item.metadata.title === "string"
     ? normalizeTitle(item.metadata.title)
@@ -200,17 +195,17 @@ function preflightBundle(bundle, options = {}) {
   const maxFiles = Number(options.maxFiles || DEFAULT_MAX_FILES)
   const maxFileBytes = Number(options.maxFileBytes || DEFAULT_MAX_FILE_BYTES)
   if (!bundle.title) {
-    return "Draft title is missing."
+    return "Note title is missing."
   }
   if (!isRegistryPostPublish(bundle.publish)) {
-    return "This draft is not configured for registry publishing."
+    return "This note is not configured for registry publishing."
   }
   if (bundle.media.length > maxFiles) {
-    return `Draft has ${bundle.media.length} media files. The registry limit is ${maxFiles}.`
+    return `Note has ${bundle.media.length} media files. The registry limit is ${maxFiles}.`
   }
   const missing = bundle.media.filter((item) => !item.exists)
   if (missing.length > 0) {
-    return `Draft references missing media: ${missing.map((item) => item.ref).join(", ")}`
+    return `Note references missing media: ${missing.map((item) => item.ref).join(", ")}`
   }
   const oversized = bundle.media.find((item) => item.bytes > maxFileBytes)
   if (oversized) {
@@ -273,10 +268,10 @@ async function uploadBundle(registryBase, token, bundle) {
   return response.data || {}
 }
-async function uploadDraftFromRequest(drafts, query, token, registryBase, options = {}) {
-  const item = await findDraftById(drafts, query.draft)
+async function uploadDraftFromRequest(notes, query, token, registryBase, options = {}) {
+  const item = await findNoteById(notes, query.draft)
   if (!item) {
-    const error = new Error("The local draft is no longer available.")
+    const error = new Error("The local note is no longer available.")
     error.status = 404
     throw error
   }
@@ -291,17 +286,17 @@ async function uploadDraftFromRequest(drafts, query, token, registryBase, option
 }
 function registerDraftImportRoutes(app, options = {}) {
-  const drafts = options.drafts
-  if (!drafts) {
-    throw new Error("drafts is required")
+  const notes = options.notes
+  if (!notes) {
+    throw new Error("notes is required")
   }
   const defaultRegistryUrl = options.defaultRegistryUrl || "https://beta.pinokio.co"
   const router = express.Router()
   router.get("/registry/draft-import/authorize-url", asyncHandler(async (req, res) => {
-    const item = await findDraftById(drafts, req.query.draft)
+    const item = await findNoteById(notes, req.query.draft)
     if (!item) {
-      return res.status(404).json({ error: "The local draft is no longer available." })
+      return res.status(404).json({ error: "The local note is no longer available." })
     }
     const bundle = await buildDraftBundle(item, req.query)
     const problem = preflightBundle(bundle, options)
@@ -312,43 +307,33 @@ function registerDraftImportRoutes(app, options = {}) {
     if (!registryBase) {
       return res.status(400).json({ error: "The registry URL is invalid." })
     }
-    const authorizeUrl = new URL("/draft-import/authorize", registryBase)
-    authorizeUrl.searchParams.set("handoff", "post_message")
-    authorizeUrl.searchParams.set("origin", requestOrigin(req))
-    authorizeUrl.searchParams.set("wait", "1")
-    if (bundle.appSlug) authorizeUrl.searchParams.set("app", bundle.appSlug)
+    const authorizeUrl = buildAuthorizeUrl(req, registryBase, item, bundle)
     res.setHeader("Cache-Control", "no-store")
     return res.json({
       draftId: item.id,
-      authorizeUrl: authorizeUrl.toString(),
-      registryOrigin: new URL(registryBase).origin
+      authorizeUrl: authorizeUrl.toString()
     })
   }))
   router.get("/registry/draft-import/start", asyncHandler(async (req, res) => {
-    const item = await findDraftById(drafts, req.query.draft)
+    const item = await findNoteById(notes, req.query.draft)
     if (!item) {
-      return renderMessage(res, 404, "Draft not found", "The local draft is no longer available.")
+      return renderMessage(res, 404, "Note not found", "The local note is no longer available.")
     }
     const bundle = await buildDraftBundle(item, req.query)
     const problem = preflightBundle(bundle, options)
     if (problem) {
-      return renderMessage(res, 400, "Draft is not ready", problem)
+      return renderMessage(res, 400, "Note is not ready", problem)
     }
     const registryBase = normalizeRegistryBase(req.query.registry, defaultRegistryUrl)
     if (!registryBase) {
       return renderMessage(res, 400, "Registry unavailable", "The registry URL is invalid.")
     }
-    const authorizeUrl = new URL("/draft-import/authorize", registryBase)
-    authorizeUrl.searchParams.set("handoff", "post_message")
-    authorizeUrl.searchParams.set("origin", requestOrigin(req))
-    if (bundle.appSlug) authorizeUrl.searchParams.set("app", bundle.appSlug)
+    const authorizeUrl = buildAuthorizeUrl(req, registryBase, item, bundle)
     res.setHeader("Cache-Control", "no-store")
     res.setHeader("Cross-Origin-Opener-Policy", "unsafe-none")
     return renderImportLauncher(res, {
       authorizeUrl: authorizeUrl.toString(),
-      draftId: item.id,
-      registryOrigin: new URL(registryBase).origin,
       autoOpen: req.query.auto === "1"
     })
   }))
@@ -369,7 +354,7 @@ function registerDraftImportRoutes(app, options = {}) {
         app: req.body && req.body.app ? String(req.body.app) : ""
       })
       const result = await uploadDraftFromRequest(
-        drafts,
+        notes,
         { draft: req.body && req.body.draft, app: req.body && req.body.app },
         token,
         registryBase,
@@ -407,7 +392,7 @@ function registerDraftImportRoutes(app, options = {}) {
       return renderMessage(res, 400, "Registry unavailable", "The registry URL is invalid.")
     }
     try {
-      const result = await uploadDraftFromRequest(drafts, req.query, token, registryBase, options)
+      const result = await uploadDraftFromRequest(notes, req.query, token, registryBase, options)
       if (result && result.editUrl) {
         return res.redirect(String(result.editUrl))
       }

package/server/features/notes/routes.js ADDED Viewed

@@ -0,0 +1,156 @@
+const express = require("express")
+const path = require("path")
+const registerDraftImportRoutes = require("./registry_import")
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next)
+  }
+}
+function isInside(candidate, parent) {
+  const relative = path.relative(parent, candidate)
+  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+}
+function parsePublishConfig(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(value)
+  } catch (_) {
+    return null
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null
+  }
+  const target = String(parsed.target || "").trim().toLowerCase()
+  const type = String(parsed.type || "post").trim().toLowerCase()
+  if (target !== "registry" || type !== "post") {
+    return null
+  }
+  const publish = { target: "registry", type: "post" }
+  const parent = parsed.parent && typeof parsed.parent === "object" && !Array.isArray(parsed.parent)
+    ? parsed.parent
+    : null
+  const parentType = parent ? String(parent.type || "").trim().toLowerCase() : ""
+  const parentUrl = parent ? String(parent.url || parent.repoUrl || "").trim() : ""
+  if (parentType === "app" && parentUrl) {
+    publish.parent = { type: "app", url: parentUrl }
+  }
+  return publish
+}
+function registerNoteRoutes(app, options = {}) {
+  const notes = options.notes
+  if (!notes) {
+    throw new Error("notes is required")
+  }
+  const kernel = options.kernel
+  const router = express.Router()
+  router.get("/notes", asyncHandler(async (req, res) => {
+    const cwd = typeof req.query.cwd === "string" ? req.query.cwd : ""
+    if (cwd && typeof notes.inspectWorkspace === "function") {
+      const resolvedCwd = path.resolve(cwd)
+      const home = kernel && kernel.homedir ? path.resolve(kernel.homedir) : ""
+      if (!home || isInside(resolvedCwd, home)) {
+        const publish = parsePublishConfig(req.query.publish)
+        const note = publish ? { publish } : undefined
+        await notes.inspectWorkspace({ cwd: resolvedCwd, note }).catch(() => null)
+      }
+    }
+    const items = await notes.listPending({ cwd })
+    res.json({
+      ok: true,
+      items
+    })
+  }))
+  router.get("/notes/:id/media/:index", asyncHandler(async (req, res) => {
+    const item = typeof notes.getPendingById === "function"
+      ? await notes.getPendingById(req.params.id)
+      : null
+    if (!item) {
+      res.status(404).send("Note not found")
+      return
+    }
+    const index = Number(req.params.index)
+    const media = Array.isArray(item.media) && Number.isInteger(index)
+      ? item.media[index]
+      : null
+    if (!media || !media.exists || !media.path) {
+      res.status(404).send("Media not found")
+      return
+    }
+    const filePath = path.resolve(media.path)
+    const basePath = path.resolve(item.resultDir)
+    const relative = path.relative(basePath, filePath)
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+      res.status(403).send("Media path is outside the note")
+      return
+    }
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(filePath)
+  }))
+  router.put("/notes/:id", express.text({ type: "*/*", limit: "6mb" }), asyncHandler(async (req, res) => {
+    if (typeof notes.savePendingById !== "function") {
+      res.status(501).json({ ok: false, error: "Note editing is unavailable." })
+      return
+    }
+    const markdown = typeof req.body === "string"
+      ? req.body
+      : (req.body && typeof req.body.markdown === "string"
+      ? req.body.markdown
+      : null)
+    if (markdown === null) {
+      res.status(400).json({ ok: false, error: "markdown is required" })
+      return
+    }
+    const revision = typeof req.get("x-pinokio-note-revision") === "string"
+      ? req.get("x-pinokio-note-revision")
+      : (req.body && typeof req.body.revision === "string"
+      ? req.body.revision
+      : "")
+    try {
+      const item = await notes.savePendingById(req.params.id, { markdown, revision })
+      if (!item) {
+        res.status(404).json({ ok: false, error: "Note not found" })
+        return
+      }
+      res.json({ ok: true, item })
+    } catch (error) {
+      if (error && error.code === "NOTE_CONFLICT") {
+        res.status(409).json({
+          ok: false,
+          error: error.message,
+          item: error.item || null
+        })
+        return
+      }
+      if (error && (error.code === "NOTE_TOO_LARGE" || error.code === "NOTE_INVALID_PATH")) {
+        res.status(400).json({ ok: false, error: error.message })
+        return
+      }
+      throw error
+    }
+  }))
+  router.get("/notes.js", (req, res) => {
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(path.resolve(__dirname, "public", "notes.js"))
+  })
+  router.get("/notes.css", (req, res) => {
+    res.setHeader("Cache-Control", "no-store")
+    res.sendFile(path.resolve(__dirname, "public", "notes.css"))
+  })
+  app.use(router)
+  registerDraftImportRoutes(app, options)
+}
+module.exports = registerNoteRoutes