acrylblends 1.2.0 → 1.3.1

package/plugins/plugin-share/package.ts

@@ -0,0 +1,186 @@
+/**
+ * Turning a plugin folder into what other people's apps can pull: a package folder and its release tarball, with the same bytes on every OS. The
+ * hub owns the tarball and the contract, blends-core what "portable" and "digest" mean; this module only decides what goes in.
+ */
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { extname, join } from 'node:path'
+import { digestFiles, pluginFiles, portabilityIssues } from '@webboxes/blends-core'
+import { packFolder, readTarball, syncServiceContract } from '@webboxes/plugin-hub'
+
+/** The package.json of a standalone plugin package: the host framework is a peer, never a second installed copy. */
+export function packageManifest(
+  name: string,
+  description: string,
+  version = '0.1.0',
+  release?: PackageRelease,
+): Record<string, unknown> {
+  return {
+    name,
+    version,
+    description,
+    ...(release === undefined
+      ? {}
+      : {
+          license: release.license,
+          repository: {
+            type: 'git',
+            url: `git+https://github.com/${release.owner}/${release.repo}.git`,
+          },
+        }),
+    type: 'module',
+    exports: { '.': './index.ts', './package.json': './package.json' },
+    // No `files` list: a plugin's plugin.json, data and .js files go with it, and the packer's own skips (node_modules, .git) apply.
+    // ACRYL measured it: a host package listed under dependencies brings a second copy of the framework, and its services stop
+    // matching after a restart. A peer names the version and installs nothing.
+    peerDependencies: { '@deepseek-ai/cordis': '4.0.4' },
+    keywords: ['cordis', 'cordis-plugin', 'acrylblends'],
+  }
+}
+
+/** Where a package is going to be released: written in now, so what is planned is byte for byte what is released. */
+export interface PackageRelease {
+  readonly owner: string
+  readonly repo: string
+  readonly license: string
+}
+
+export interface PackageOptions {
+  /** This version, instead of the one already packaged. */
+  readonly version?: string
+  readonly release?: PackageRelease
+}
+
+export interface PackagedPlugin {
+  readonly dir: string
+  readonly version: string
+  readonly files: readonly string[]
+  /** The release file, next to the package folder. */
+  readonly tarball: string
+  /** The tarball's sha512, as the registry lists it. */
+  readonly integrity: string
+  /** The sha256 of the plugin's content, which a source can name (`@sha256:<digest>`). */
+  readonly digest: string
+}
+
+/** Text whose line endings an editor or git on Windows may change: LF in the package, so those endings are not part of the plugin's identity. */
+const TEXT = new Set([
+  '.ts',
+  '.mts',
+  '.cts',
+  '.tsx',
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.jsx',
+  '.json',
+  '.md',
+  '.txt',
+  '.css',
+  '.html',
+  '.yml',
+  '.yaml',
+  '.svg',
+])
+
+function withLineFeeds(dir: string): void {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) withLineFeeds(path)
+    else if (entry.isFile() && TEXT.has(extname(entry.name).toLowerCase())) {
+      const text = readFileSync(path, 'utf8')
+      if (text.includes('\r\n')) writeFileSync(path, text.replaceAll('\r\n', '\n'))
+    }
+  }
+}
+
+/** What the hub's share would otherwise add on the way out, changing the bytes after they were planned. */
+function markPublic(target: string): void {
+  const file = join(target, 'package.json')
+  const manifest = JSON.parse(readFileSync(file, 'utf8')) as Record<string, unknown>
+  writeFileSync(
+    file,
+    `${JSON.stringify({ ...manifest, acryl: { ...(manifest.acryl as object), visibility: 'public' } }, null, 2)}\n`,
+  )
+}
+
+function versionIn(target: string): string | undefined {
+  try {
+    const { version } = JSON.parse(readFileSync(join(target, 'package.json'), 'utf8')) as {
+      version?: unknown
+    }
+    return typeof version === 'string' ? version : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Package the plugin in `source` as `<packages>/<name>/` and `<packages>/<name>-<version>.tgz`. The person's folder is not touched. A version already
+ * packaged stays: a release is made once, and a person bumps it deliberately.
+ * @throws when the plugin would not work on every OS or its contract cannot be read; no package is left.
+ */
+export async function packagePlugin(
+  source: string,
+  packages: string,
+  name: string,
+  description: string,
+  options: PackageOptions = {},
+): Promise<PackagedPlugin> {
+  const target = join(packages, name)
+  const version = options.version ?? versionIn(target)
+  rmSync(target, { recursive: true, force: true })
+  mkdirSync(packages, { recursive: true })
+  cpSync(source, target, { recursive: true, filter: (path) => !path.includes('node_modules') })
+  try {
+    writeFileSync(
+      join(target, 'package.json'),
+      `${JSON.stringify(packageManifest(name, description, version, options.release), null, 2)}\n`,
+    )
+    if (!existsSync(join(target, 'README.md'))) {
+      writeFileSync(
+        join(target, 'README.md'),
+        `# ${name}\n\n${description}\n\nA Cordis plugin. Once it is released, pull it into an ACRYLBLENDS app while that app runs (\`npm run dev\`): \`npm run acryl -- plugin pull github:<owner>/<repo>\`.\n`,
+      )
+    }
+    withLineFeeds(target)
+    const issues = portabilityIssues(pluginFiles(target))
+    if (issues.length > 0)
+      throw new Error(
+        `it would not work on every OS: ${issues.map((issue) => `${issue.path}: ${issue.reason}`).join('; ')}`,
+      )
+    // The contract other people's apps and the registry read: what the plugin needs and provides, from its code.
+    const contract = await syncServiceContract(target)
+    if (!contract.ok)
+      throw new Error(`its service contract cannot be read: ${contract.errors.join('; ')}`)
+    if (options.release !== undefined) markPublic(target)
+    const packed = packFolder(target)
+    const tarball = join(packages, packed.fileName)
+    writeFileSync(tarball, packed.tarball)
+    const digest = digestFiles(
+      readTarball(packed.tarball).map(({ path, content }) => ({
+        path,
+        bytes: content,
+        kind: 'file' as const,
+      })),
+    )
+    return {
+      dir: target,
+      version: packed.version,
+      files: packed.files,
+      tarball,
+      integrity: packed.integrity,
+      digest,
+    }
+  } catch (cause) {
+    rmSync(target, { recursive: true, force: true })
+    throw cause
+  }
+}

package/plugins/plugin-share/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "plugin-share",
+  "description": "Share plugins between people. Pull one someone released into the running app: fetched without running anything, checked by digest and for every OS, then installed live. Publish one, only as a plan a person confirmed.",
+  "requires": ["instance", "extensions", "manifest"],
+  "inject": ["extensions", "appInstance"],
+  "provides": ["pluginShare"],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@webboxes/app-persistence": "0.1.1",
+    "@webboxes/blends-core": "0.5.0",
+    "@webboxes/plugin-hub": "0.2.0",
+    "yaml": "2.9.0"
+  },
+  "mount": "mount it after extensions, in development builds: root.plugin(pluginShare, { dir: join(root, 'plugins') }); dir must be an extensions source"
+}

package/plugins/plugin-share/publish.ts

@@ -0,0 +1,65 @@
+/**
+ * Publishing a plugin: what a person is asked to say yes to, and the comparison that makes the yes mean exactly that. Pure; the service does the I/O.
+ */
+import type { PublishGitPort, RepositoryHostPort } from '@webboxes/plugin-hub'
+
+/** Everything that leaves the machine, named before anything does. */
+export interface PublishPlan {
+  readonly owner: string
+  readonly repo: string
+  readonly version: string
+  readonly visibility: 'public'
+  readonly license: string
+  /** The repository does not exist yet: publishing creates it. */
+  readonly createsRepository: boolean
+  /** The version already released there; the plan then releases the next patch. */
+  readonly released?: string
+  readonly files: readonly string[]
+  /** The sha512 of the release file. */
+  readonly integrity: string
+  /** The sha256 of the plugin's content. */
+  readonly digest: string
+  /** What a friend runs to get exactly these bytes. */
+  readonly pullLine: string
+}
+
+export interface PublishRefused {
+  readonly ok: false
+  readonly reason: string
+  readonly next: string
+}
+
+export type PublishResult =
+  | {
+      readonly ok: true
+      readonly url: string
+      readonly releaseUrl: string
+      readonly version: string
+      readonly integrity: string
+      readonly digest: string
+      readonly pullLine: string
+    }
+  | PublishRefused
+
+export interface PublishOptions {
+  /** The account or organization; the signed-in one when absent. */
+  readonly owner?: string
+  /** The license the plugin is offered under, as an SPDX id; MIT when absent. The plan shows it before the person says yes. */
+  readonly license?: string
+}
+
+/** Where a publish goes through: the person's own `gh` and `git`. A test passes stand-ins, so no test publishes. */
+export interface PublishPorts {
+  readonly host: RepositoryHostPort
+  readonly git: PublishGitPort
+}
+
+/** The line a friend copies: it names the bytes, so the check comes for free. */
+export const pullLineOf = (owner: string, repo: string, version: string, digest: string): string =>
+  `npm run acryl -- plugin pull github:${owner}/${repo}@${version}@sha256:${digest}`
+
+/** The same plan: what the person confirmed is what would be published now. `released` only explains the version, and is gone once the next one is packaged. */
+export function samePlan(a: PublishPlan, b: PublishPlan): boolean {
+  const compared = ({ released: _released, ...rest }: PublishPlan) => JSON.stringify(rest)
+  return compared(a) === compared(b)
+}

package/plugins/plugin-share/pull-check.ts

@@ -0,0 +1,129 @@
+/**
+ * What decides whether a pulled plugin may enter this app. Pure, over the files of the package: nothing here touches a disk or runs the plugin,
+ * so a refusal has nothing to undo (Clean Architecture: policy free of I/O).
+ */
+import { digestFiles, type PluginFile, portabilityIssues } from '@webboxes/blends-core'
+import { hostInjectFromSource } from '@webboxes/plugin-hub'
+
+export type Refusal =
+  | 'source'
+  | 'fetch'
+  | 'name'
+  | 'digest'
+  | 'portability'
+  | 'dependencies'
+  | 'entry'
+  | 'inject'
+  | 'missing-service'
+  | 'folder-exists'
+  | 'install'
+
+export interface PullRefused {
+  readonly ok: false
+  readonly refusal: Refusal
+  readonly reason: string
+  /** What the person can do about it. */
+  readonly next: string
+}
+
+export const refuse = (refusal: Refusal, reason: string, next: string): PullRefused => ({
+  ok: false,
+  refusal,
+  reason,
+  next,
+})
+
+const SHA256 = /^[0-9a-f]{64}$/
+const DIGEST_MARK = '@sha256:'
+
+/** The source a person wrote, split into where it comes from and the content digest it names. @throws when the digest is malformed. */
+export function splitDigest(input: string): { readonly source: string; readonly digest?: string } {
+  const at = input.lastIndexOf(DIGEST_MARK)
+  if (at === -1) return { source: input }
+  const digest = input.slice(at + DIGEST_MARK.length)
+  if (!SHA256.test(digest))
+    throw new Error(`"${digest}" is not a content digest: it has 64 lowercase hex characters`)
+  return { source: input.slice(0, at), digest }
+}
+
+/** The entry files the extensions folder loads, in its order. */
+const ENTRIES = ['index.ts', 'index.js', 'index.mjs']
+
+const text = (file: PluginFile): string => Buffer.from(file.bytes).toString('utf8')
+
+export interface PullContext {
+  /** The content digest the source names. */
+  readonly digest?: string | undefined
+  /** Whether the extensions folder can hold a plugin of this name. */
+  readonly nameFits: (name: string) => boolean
+  /** Whether this app has the service right now. */
+  readonly hasService: (name: string) => boolean
+}
+
+/** The first reason this package may not enter the app, or undefined. */
+export function pullRefusal(
+  manifest: Readonly<Record<string, unknown>>,
+  files: readonly PluginFile[],
+  context: PullContext,
+): PullRefused | undefined {
+  const name = String(manifest.name)
+  if (!context.nameFits(name)) {
+    return refuse(
+      'name',
+      `the package is called "${name}", which a folder in plugins/ cannot hold`,
+      'ask its author to release it under lowercase letters, digits and dashes',
+    )
+  }
+  const digest = digestFiles(files)
+  if (context.digest !== undefined && context.digest !== digest) {
+    return refuse(
+      'digest',
+      `${digest} is not the digest the source names (${context.digest}); these are different bytes`,
+      'ask the person who gave you the digest which release they meant',
+    )
+  }
+  const issues = portabilityIssues(files)
+  if (issues.length > 0) {
+    return refuse(
+      'portability',
+      issues.map((issue) => `${issue.path}: ${issue.reason}`).join('; '),
+      'ask its author to fix this and release again, so it works on every OS',
+    )
+  }
+  const dependencies = Object.keys(
+    (manifest.dependencies as Record<string, unknown> | undefined) ?? {},
+  )
+  if (dependencies.length > 0) {
+    return refuse(
+      'dependencies',
+      `it needs ${dependencies.join(', ')} installed, and a pull installs nothing`,
+      'ask its author to bundle them or name them as peers',
+    )
+  }
+  const entry = ENTRIES.flatMap((path) => files.filter((file) => file.path === path))[0]
+  if (entry === undefined) {
+    return refuse(
+      'entry',
+      `it has none of ${ENTRIES.join(', ')} at its top level`,
+      'this package is not a plugin an app can load; ask its author',
+    )
+  }
+  const inject = hostInjectFromSource(text(entry))
+  if (inject !== undefined && 'error' in inject) {
+    return refuse(
+      'inject',
+      `${inject.error}. A pull reads what a plugin needs without running it`,
+      'ask its author to list the services as plain names',
+    )
+  }
+  const missing = (inject?.names ?? []).filter((service) => !context.hasService(service))
+  if (missing.length > 0) return missingServices(missing)
+  return undefined
+}
+
+export const missingServices = (missing: readonly string[]): PullRefused =>
+  refuse(
+    'missing-service',
+    `it needs ${missing.join(', ')}, which this app does not have`,
+    'add the plugin that provides it, then pull again',
+  )

package/plugins/plugin-share/pulled-records.ts

@@ -0,0 +1,70 @@
+/**
+ * What an app remembers about the plugins it pulled: their source and digests, in the `plugin-share` row's config of `blend.yaml`. A row's config is
+ * resolved into `blend.lock.json` too, so the lock records them with no new format, and a copy of the app can fetch exactly the same bytes. Pure text
+ * to text; comments and the person's formatting stay.
+ */
+import { isMap, isSeq, parseDocument } from 'yaml'
+
+export const ROW = 'plugin-share'
+
+export interface PulledRecord {
+  /** `github:<owner>/<repo>@<version>` or an https address: something another machine can fetch. */
+  readonly source: string
+  /** The sha512 of the release file. */
+  readonly integrity: string
+  /** The sha256 of the plugin's content. */
+  readonly digest: string
+}
+
+const isRecord = (value: unknown): value is PulledRecord => {
+  const record = value as Partial<Record<keyof PulledRecord, unknown>> | null
+  return (
+    typeof record?.source === 'string' &&
+    typeof record.integrity === 'string' &&
+    typeof record.digest === 'string'
+  )
+}
+
+/** The plugins this definition remembers pulling. */
+export function pulledRecords(text: string): Readonly<Record<string, PulledRecord>> {
+  const rows = (parseDocument(text).toJS() as { spec?: { rows?: unknown } } | null)?.spec?.rows
+  if (!Array.isArray(rows)) return {}
+  const pulled = (
+    rows.find((row: { name?: unknown }) => row?.name === ROW) as
+      | { config?: { pulled?: unknown } }
+      | undefined
+  )?.config?.pulled
+  if (typeof pulled !== 'object' || pulled === null) return {}
+  return Object.fromEntries(
+    Object.entries(pulled).filter(([, record]) => isRecord(record)),
+  ) as Record<string, PulledRecord>
+}
+
+/**
+ * The definition with one plugin's record written, or taken out when `record` is undefined. Unchanged when it has no `plugin-share` row: an app
+ * composed without the row has nowhere to remember.
+ */
+export function withPulledRecord(
+  text: string,
+  name: string,
+  record: PulledRecord | undefined,
+): string {
+  const document = parseDocument(text)
+  const rows = document.getIn(['spec', 'rows'])
+  if (!isSeq(rows)) return text
+  const row = rows.items.find((item) => isMap(item) && item.get('name') === ROW)
+  if (!isMap(row)) return text
+  if (record === undefined) {
+    if (!row.hasIn(['config', 'pulled', name])) return text
+    row.deleteIn(['config', 'pulled', name])
+    const left = row.getIn(['config', 'pulled'])
+    if (isMap(left) && left.items.length === 0) row.deleteIn(['config', 'pulled'])
+    const config = row.get('config')
+    if (isMap(config) && config.items.length === 0) row.delete('config')
+  } else {
+    row.setIn(['config'], row.get('config') ?? document.createNode({}))
+    if (!row.hasIn(['config', 'pulled'])) row.setIn(['config', 'pulled'], document.createNode({}))
+    row.setIn(['config', 'pulled', name], document.createNode(record))
+  }
+  return String(document)
+}

package/templates/agent/.gitattributes

@@ -0,0 +1,2 @@
+# Every checkout has the same line endings, on every OS. A plugin's digest counts every byte, so a CRLF checkout would make it a different plugin.
+* text=auto eol=lf

package/templates/agent/blend.yaml

@@ -49,6 +49,8 @@ spec:
         approval: "{{parameters.approval}}"
     - id: builder
       name: builder
+    - id: plugin-share
+      name: plugin-share
     - id: save
       name: save
     # The panel: a chat button on every page in development (the app's own agent, or Codex, Claude or pi started in this folder). It starts nothing in production.

package/templates/agent/src/app.ts

@@ -20,6 +20,7 @@ import {
   type ParameterValue,
 } from '../plugins/manifest/index.ts'
 import { ASSISTANT_PROMPT, type OpenAIConfig, openai } from '../plugins/openai/index.ts'
+import { pluginShare } from '../plugins/plugin-share/index.ts'
 import { sandboxPlugin } from '../plugins/sandbox/index.ts'
 import { save } from '../plugins/save/index.ts'
 import { tasks } from '../plugins/tasks/index.ts'
@@ -36,6 +37,7 @@ export const registry = {
   'acryl-state': state,
   extensions,
   builder,
+  'plugin-share': pluginShare,
   save,
   sandbox: sandboxPlugin,
   routes,
@@ -77,6 +79,7 @@ export interface App {
 const DEVELOPMENT_ROWS: Record<string, string> = {
   agent: 'POST /ask runs the agent, which spends the model key and calls its tools',
   builder: 'the agent can write plugin source into plugins/',
+  'plugin-share': 'a plugin pulled from a release runs in this process',
   extensions:
     'a plugin installed live runs in this process, and POST /extensions/approve decides installs',
 }
@@ -213,8 +216,11 @@ export async function composeInto(
             ...(legacy ? [{ dir: legacyDir, trust: 'install' as const }] : []),
           ],
           rows: ownRows,
+          // Messages name a route as the plugin wrote it, not under the frame's canvas prefix.
+          ...(options.host === true ? { routePrefix: FRAME_MOUNT_PREFIX } : {}),
         },
         builder: { dir: extensionsDir },
+        'plugin-share': { dir: extensionsDir },
         ...(assistant
           ? {
               // Every answer comes right after a look, so it says what the visitor's page shows now.

package/templates/agent/template.json

@@ -12,6 +12,7 @@
     "sandbox",
     "extensions",
     "builder",
+    "plugin-share",
     "agent-panel",
     "manifest",
     "save",

package/templates/blank/.gitattributes

@@ -0,0 +1,2 @@
+# Every checkout has the same line endings, on every OS. A plugin's digest counts every byte, so a CRLF checkout would make it a different plugin.
+* text=auto eol=lf

package/templates/blank/blend.yaml

@@ -25,6 +25,9 @@ spec:
     # a row is never started twice. Read-only when NODE_ENV=production.
     - id: extensions
       name: extensions
+    # Sharing: `npm run acryl -- plugin pull github:<owner>/<repo>@<version>` installs a plugin someone released (development only).
+    - id: plugin-share
+      name: plugin-share
     - id: server
       name: acryl-node-server
       config:

package/templates/blank/src/app.ts

@@ -15,6 +15,7 @@ import {
   loadManifest,
   type ParameterValue,
 } from '../plugins/manifest/index.ts'
+import { pluginShare } from '../plugins/plugin-share/index.ts'
 import { doorEnabled } from './door.ts'
 import { FRAME_MOUNT_PREFIX, routes } from './routes.ts'
 
@@ -25,6 +26,7 @@ export const registry = {
   'acryl-door': door,
   home,
   extensions,
+  'plugin-share': pluginShare,
   routes,
 }
 
@@ -106,6 +108,8 @@ export async function composeInto(
   const leaveOut = new Set<string>(options.host === true ? HOST_ROWS : [])
   if (!own) leaveOut.add('acryl-node-server').add('acryl-door')
   if (!doorEnabled()) leaveOut.add('acryl-door')
+  // A pull runs a stranger's code and a publish leaves the machine: development only, like the door.
+  if (process.env.NODE_ENV === 'production') leaveOut.add('plugin-share')
   const manifest = without(read, ...leaveOut)
   // The rows that name one of the app's own plugin folders (a feature: plugins/<name>/ and its row) rather than a registry import. Each one that runs
   // is imported here; all of them, off or on, belong to their row, so the extensions row never starts them a second time.
@@ -129,7 +133,11 @@ export async function composeInto(
         ...(process.env.NODE_ENV === 'production' ? { readOnly: true } : {}),
         sources: [{ dir: PLUGINS_DIR, trust: 'install' }],
         rows: ownRows,
+        // Messages name a route as the plugin wrote it, not under the frame's canvas prefix.
+        ...(prefix === undefined ? {} : { routePrefix: prefix }),
       },
+      // Pulled plugins go where the extensions row installs from.
+      'plugin-share': { dir: PLUGINS_DIR },
       // Only the app's own server listens; the frame host owns the server and its port.
       ...(own ? { server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 } } : {}),
     },

package/templates/blank/template.json

@@ -7,6 +7,7 @@
     "save",
     "home",
     "extensions",
+    "plugin-share",
     "acryl-door",
     "acryl-web-server",
     "acryl-page"

package/templates/chat/.gitattributes

@@ -0,0 +1,2 @@
+# Every checkout has the same line endings, on every OS. A plugin's digest counts every byte, so a CRLF checkout would make it a different plugin.
+* text=auto eol=lf

package/templates/chat/blend.yaml

@@ -24,6 +24,9 @@ spec:
     # Read-only when NODE_ENV=production.
     - id: extensions
       name: extensions
+    # Sharing: `npm run acryl -- plugin pull github:<owner>/<repo>@<version>` installs a plugin someone released (development only).
+    - id: plugin-share
+      name: plugin-share
     - id: server
       name: acryl-node-server
       config:

package/templates/chat/src/app.ts

@@ -15,6 +15,7 @@ import {
   loadManifest,
   type ParameterValue,
 } from '../plugins/manifest/index.ts'
+import { pluginShare } from '../plugins/plugin-share/index.ts'
 import { doorEnabled } from './door.ts'
 import { FRAME_MOUNT_PREFIX, routes } from './routes.ts'
 
@@ -25,6 +26,7 @@ export const registry = {
   'acryl-node-server': nodeServer,
   'acryl-door': door,
   extensions,
+  'plugin-share': pluginShare,
   routes,
 }
 
@@ -106,6 +108,8 @@ export async function composeInto(
   const leaveOut = new Set<string>(options.host === true ? HOST_ROWS : [])
   if (!own) leaveOut.add('acryl-node-server').add('acryl-door')
   if (!doorEnabled()) leaveOut.add('acryl-door')
+  // A pull runs a stranger's code and a publish leaves the machine: development only, like the door.
+  if (process.env.NODE_ENV === 'production') leaveOut.add('plugin-share')
   const manifest = without(read, ...leaveOut)
   // The rows that name one of the app's own plugin folders (a feature: plugins/<name>/ and its row) rather than a registry import. Each one that runs
   // is imported here; all of them, off or on, belong to their row, so the extensions row never starts them a second time.
@@ -134,7 +138,11 @@ export async function composeInto(
         ...(process.env.NODE_ENV === 'production' ? { readOnly: true } : {}),
         sources: [{ dir: PLUGINS_DIR, trust: 'install' }],
         rows: ownRows,
+        // Messages name a route as the plugin wrote it, not under the frame's canvas prefix.
+        ...(prefix === undefined ? {} : { routePrefix: prefix }),
       },
+      // Pulled plugins go where the extensions row installs from.
+      'plugin-share': { dir: PLUGINS_DIR },
       // Only the app's own server listens; the frame host owns the server and its port.
       ...(own ? { server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 } } : {}),
     },

package/templates/chat/template.json

@@ -7,6 +7,7 @@
     "manifest",
     "save",
     "extensions",
+    "plugin-share",
     "acryl-door",
     "acryl-web-server",
     "acryl-page"

package/templates/nodejs/.gitattributes

@@ -0,0 +1,2 @@
+# Every checkout has the same line endings, on every OS. A plugin's digest counts every byte, so a CRLF checkout would make it a different plugin.
+* text=auto eol=lf

package/templates/nodejs/blend.yaml

@@ -21,6 +21,9 @@ spec:
     # Read-only when NODE_ENV=production.
     - id: extensions
       name: extensions
+    # Sharing: `npm run acryl -- plugin pull github:<owner>/<repo>@<version>` installs a plugin someone released (development only).
+    - id: plugin-share
+      name: plugin-share
     - id: server
       name: acryl-node-server
       config: