mikser-io-drive 0.14.0 → 0.16.0

package/.github/workflows/publish.yml

@@ -0,0 +1,73 @@
+# Publish to npm without a stored token.
+#
+# npm is retiring tokens that skip the second factor — its own token page says
+# "Publish new versions directly (deprecated — ends January 2027)". This is the
+# replacement: the job proves who it is at publish time with a short-lived
+# credential GitHub issues and npm verifies, so npm trusts "the publish.yml
+# workflow in this repository" rather than a string.
+#
+# There is no NODE_AUTH_TOKEN and no secret to configure. Nothing to leak,
+# expire or rotate — the two ways publishing broke in September 2026.
+#
+# Link it once on npm: the package → Settings → Trusted Publisher → GitHub
+# Actions, naming this repository and this filename. Until that exists the
+# publish step fails rather than falling back to something weaker.
+
+name: Publish
+
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      # The whole mechanism. Without it npm has nothing to verify.
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      # Trusted publishing landed in npm 11.5.1.
+      - name: Use an npm that can do trusted publishing
+        run: npm install -g npm@latest
+
+      # `npm install`, not `npm ci`: these packages are developed in a
+      # workspace, so dependencies hoist to its root and each package's own
+      # lockfile is never read locally. They drift silently, and CI is the only
+      # thing that would ever read them.
+      - run: npm install --no-audit --no-fund
+        env:
+          # puppeteer downloads a browser on install; nothing in the release
+          # path renders a page.
+          PUPPETEER_SKIP_DOWNLOAD: '1'
+
+      # The tag is the release. A tag that disagrees with package.json would
+      # publish a version nobody asked for.
+      - name: Tag must match package.json
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG="$(node -p 'require("./package.json").version')"
+          if [ "$TAG" != "$PKG" ]; then
+            echo "tag v$TAG does not match package.json $PKG"
+            exit 1
+          fi
+          echo "publishing $PKG"
+
+      # The suite runs here now. It did not before: these packages declared
+      # mikser-io only as a peerDependency (npm does not install a package's
+      # own peers) or as file:../mikser-io (a path that exists on a laptop and
+      # nowhere else), so a standalone clone could not resolve the engine it
+      # tests against. Both are now real devDependencies with version ranges,
+      # which npm still satisfies from the workspace locally.
+      - run: npm test
+
+      - run: npm publish --access public

package/lib/authenticator.js

@@ -1,5 +1,10 @@
 import { UnauthorizedError, ForbiddenError } from 'nephele'
 import { authorize } from 'mikser-io'
+// The one implementation of "does this principal hold it", including the
+// `*` wildcard — checked here rather than re-derived, because two gates in
+// this file and one in mikser-io-auth each had their own `.includes` and a
+// wildcard added to the shared function reached none of them.
+import { hasCapability } from 'mikser-io'
 
 // Bridges Nephele's Authenticator contract onto the engine's verifier seam
 // (ADR-0012), so WebDAV authenticates against the same htpasswd identity as
@@ -80,8 +85,7 @@ export class MikserAuthenticator {
         // Capability gate for this endpoint. `capabilities: null` means the
         // credential is not capability-scoped (no map configured, or a bare
         // static token), which passes — same rule as every other surface.
-        if (this.#capability && principal.capabilities != null &&
-            !principal.capabilities.includes(this.#capability)) {
+        if (this.#capability && !hasCapability(principal, this.#capability)) {
             this.#logger?.debug?.('drive: %j lacks %j', principal.subject, this.#capability)
             throw new ForbiddenError(`Your credential does not carry '${this.#capability}'.`)
         }
@@ -94,8 +98,7 @@ export class MikserAuthenticator {
         // therefore never means what it looks like it means.) The authenticator
         // is the earliest place that holds both the principal and the method.
         if (this.#writeCapability && WRITE_METHODS.has(request.method) &&
-            principal.capabilities != null &&
-            !principal.capabilities.includes(this.#writeCapability)) {
+            !hasCapability(principal, this.#writeCapability)) {
             this.#logger?.debug?.('drive: %j may not %s — lacks %j',
                 principal.subject, request.method, this.#writeCapability)
             throw new ForbiddenError(`Your credential does not carry '${this.#writeCapability}'.`)

package/lib/files.js

@@ -30,7 +30,7 @@ import { lookup as mimeLookup } from 'mime-types'
 // Drive writes with fs directly rather than through a collection handle, so
 // it records its own paths. Without this a media replacement — the change most
 // worth taking back — falls into the unattributed sweep.
-import { looksTextual, recordChangeSetWrite, explainRefusal, actingRole } from 'mikser-io'
+import { looksTextual, recordChangeSetWrite, explainRefusal, actingRole, useService } from 'mikser-io'
 import { readFile, writeFile, mkdir, rename, stat, unlink, open } from 'node:fs/promises'
 import {
     runtime, readEntity, findEntities, nextCycleId, whenCycleCompletes, checksum,
@@ -246,11 +246,22 @@ async function settledCycle(cycleId) {
     }
 }
 
-export function registerFileTools({ runtime: rt, endpoints, capabilityOf, writeCapabilityOf, logger }) {
-    const mcp = rt.options.mcp
+export function registerFileTools({ runtime, endpoints, capabilityOf, writeCapabilityOf, logger }) {
+    // Asked of core rather than read off runtime.options.mcp, so this package
+    // no longer reaches into a sibling's namespace and no longer depends on
+    // where the mcp plugin sits in the plugins array.
+    //
+    // Registered through the SUBSTRATE, not the engine registry, on purpose:
+    // these tools declare `mutates`, and the substrate is what gives a
+    // mutating tool its changeSet parameters and runs its handler inside the
+    // change set. Registering them against the engine would leave their
+    // writes unattributable — the one failure nothing downstream can repair.
+    // They still reach the CLI, because the substrate mirrors every
+    // registration into the engine registry with the wrapped handler intact.
+    const mcp = useService('mcp')
     if (!mcp?.registerTool) return
 
-    const workingFolder = () => rt.options.workingFolder
+    const workingFolder = () => runtime.options.workingFolder
     const folderOf = (name) => {
         const ep = endpoints[name]
         if (!ep) return null
@@ -484,10 +495,10 @@ export function registerFileTools({ runtime: rt, endpoints, capabilityOf, writeC
             if (found.endpoint && !holds(principal, capabilityOf(found.endpoint))) {
                 return fail(explainRefusal({
                     capability: capabilityOf(found.endpoint),
-                    role: actingRole(principal?.roles ?? [], rt.options?.roles?.catalogue ?? {}),
+                    role: actingRole(principal?.roles ?? [], runtime.options?.roles?.catalogue ?? {}),
                     target: pathish,
-                    catalogue: rt.options?.roles?.catalogue ?? {},
-                    summaries: rt.options?.roles?.summaries ?? {},
+                    catalogue: runtime.options?.roles?.catalogue ?? {},
+                    summaries: runtime.options?.roles?.summaries ?? {},
                 }))
             }
 
@@ -641,7 +652,7 @@ export function registerFileTools({ runtime: rt, endpoints, capabilityOf, writeC
                 // Who breaks. The reference is the served URL where there is
                 // one, because that is the string documents actually carry.
                 const reference = found.entity?.meta?.url ?? found.entity?.id ?? null
-                const referrers = reference && rt.refs?.inboundFor ? rt.refs.inboundFor(reference) : []
+                const referrers = reference && runtime.refs?.inboundFor ? runtime.refs.inboundFor(reference) : []
                 staged.push({ input: pathish, file: found.file, entity: found.entity, owning, reference, referrers })
             }
 
@@ -695,7 +706,7 @@ export function registerFileTools({ runtime: rt, endpoints, capabilityOf, writeC
             // file at a new URL and, where git sync is on, commit it. One stamp
             // for the batch, so undoing it is one move back.
             const stamp = new Date().toISOString().replace(/[:.]/g, '-')
-            const trashRoot = path.join(rt.options.runtimeFolder ?? path.join(workingFolder(), 'runtime'),
+            const trashRoot = path.join(runtime.options.runtimeFolder ?? path.join(workingFolder(), 'runtime'),
                                         'trash', stamp)
             const results = []
             for (const s of staged) {
@@ -827,7 +838,7 @@ export function registerFileTools({ runtime: rt, endpoints, capabilityOf, writeC
             // URLs differently is not second-guessed.
             for (const s of staged) {
                 s.oldRef = s.entity?.meta?.url ?? null
-                s.referrers = s.oldRef && rt.refs?.inboundFor ? rt.refs.inboundFor(s.oldRef) : []
+                s.referrers = s.oldRef && runtime.refs?.inboundFor ? runtime.refs.inboundFor(s.oldRef) : []
                 s.newRef = s.oldRef
                     ? s.oldRef.slice(0, s.oldRef.length - path.relative(folderOf(s.owning), s.file).length) + s.dest
                     : null

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "mikser-io-drive",
-  "version": "0.14.0",
-  "description": "WebDAV for mikser-io. Exposes working-folder directories as WebDAV endpoints via Nephele, authenticated through mikser-io-auth's htpasswd identity — so content can be edited from Finder, Explorer or any DAV client and the build picks the change up.",
+  "version": "0.16.0",
+  "description": "WebDAV for mikser-io. Exposes working-folder directories as WebDAV endpoints via Nephele, authenticated through mikser-io-auth's htpasswd identity \u2014 so content can be edited from Finder, Explorer or any DAV client and the build picks the change up.",
   "main": "index.js",
   "type": "module",
+  "allowScripts": {
+    "better-sqlite3": true
+  },
   "scripts": {
     "test": "node --no-warnings --test --test-reporter=spec 'test/**/*.test.js'"
   },
@@ -25,7 +28,7 @@
   },
   "homepage": "https://github.com/almero-digital-marketing/mikser-io-drive#readme",
   "peerDependencies": {
-    "mikser-io": "^9.52.0",
+    "mikser-io": "^10.0.0",
     "zod": "^4.0.0"
   },
   "dependencies": {
@@ -38,8 +41,9 @@
     "bcryptjs": "^3.0.0",
     "express": "^5.2.1",
     "globby": "^15.0.0",
-    "mikser-io": "file:../mikser-io",
-    "mikser-io-auth": "file:../mikser-io-auth",
+    "mikser-io": "^10.0.0",
+    "mikser-io-auth": "^0.13.0",
+    "mikser-io-mcp": "^2.0.0",
     "webdav": "^5.10.0",
     "zod": "^4.0.0"
   }

package/test/derived.test.js

@@ -3,18 +3,21 @@ import assert from 'node:assert/strict'
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { createRequire } from 'node:module'
 
-// `derived` is a passthrough of what the assets plugin stamped, and it was the
-// one field in the add response I could not verify by unit test: it only exists
-// when a real preset matched and a real derivative was produced. So this runs
-// the whole pipeline — files → assets → renderPreset → sharp — against a live
-// server and asks the tool.
+// `derived` is `entity.meta.presets`, spread onto the add response. What this
+// package owns is that passthrough: the field it reads and the field it
+// writes, over a live server through the real tool.
 //
-// The read is three lines. What this pins is that those three lines name the
-// field the pipeline actually writes, which is the half that silently rots when
-// the plugin changes shape.
+// It used to produce a real derivative to get there — files → assets →
+// renderPreset → sharp — which bought two assertions beyond the passthrough
+// (a .webp suffix, a URL unlike the source) at the price of a hard dependency
+// on mikser-io-assets, a live image encode, and a `skip` whenever sharp was
+// absent, so on many machines it never ran at all. Those two assertions are
+// presetUrl's behaviour and are unit-tested in mikser-io-assets. A five-line
+// plugin stamps the field on the same hook instead.
 //
 // Two mistakes made while building it, both of which produce SILENCE rather
 // than an error and are worth knowing:
@@ -27,15 +30,7 @@ import { createRequire } from 'node:module'
 //     (/media/**) matches nothing, produces no variant, and reports only that
 //     none matched.
 
-// sharp is mikser-io's dependency, not this package's — the fixture needs it
-// because a preset does the actual image work. Resolved from there rather than
-// from here, and the fixture's node_modules is built from mikser-io's so the
-// spawned build finds it too.
-const require_ = createRequire(import.meta.url)
 const ENGINE = path.resolve(import.meta.dirname, '..', '..', 'mikser-io')
-const hasSharp = (() => {
-    try { require_.resolve('sharp', { paths: [ENGINE] }); return true } catch { return false }
-})()
 
 const PORT = 4211
 const PNG = Buffer.from(
@@ -60,10 +55,8 @@ async function rpc(token, method, params, session) {
 }
 
 before(async (t) => {
-    if (!hasSharp) return
     dir = await mkdtemp(path.join(tmpdir(), 'mikser-derived-'))
     await mkdir(path.join(dir, 'media'), { recursive: true })
-    await mkdir(path.join(dir, 'presets'), { recursive: true })
     await mkdir(path.join(dir, 'documents'), { recursive: true })
 
     // node_modules by symlink, so the fixture resolves the working copies.
@@ -77,33 +70,56 @@ before(async (t) => {
             await symlink(path.join(donor, entry), path.join(dir, 'node_modules', entry)).catch(() => {})
         }
     }
+    // Point at the WORKING COPY of each sibling when there is one — the whole
+    // point is to exercise this checkout, not the last release. In CI there is
+    // no workspace: the repository is cloned alone and the siblings come from
+    // npm, already symlinked by the donor loop above. Replacing them there
+    // removed the installed copy and linked to a path that does not exist, so
+    // the fixture had no engine at all and the server never started. Both
+    // steps failed silently — the rm succeeded, the symlink was swallowed by
+    // .catch — which is why it read as "Cannot find module .../app.js".
     for (const pkg of ['mikser-io', 'mikser-io-mcp', 'mikser-io-drive']) {
+        const sibling = path.resolve(here, '..', pkg)
+        if (!existsSync(sibling)) continue
         await rm(path.join(dir, 'node_modules', pkg), { recursive: true, force: true })
-        await symlink(path.resolve(here, '..', pkg), path.join(dir, 'node_modules', pkg)).catch(() => {})
+        await symlink(sibling, path.join(dir, 'node_modules', pkg)).catch(() => {})
     }
 
-    // A preset is a module whose DEFAULT export does the work.
-    await writeFile(path.join(dir, 'presets/web.js'),
-        "import sharp from 'sharp'\n"
-        + 'export const revision = 1\n'
-        + "export const format = 'webp'\n"
-        + 'export const options = { width: 8 }\n'
-        + 'export default ({ entity: { source, destination }, options }) =>\n'
-        + '    sharp(source).resize(options).webp().toFile(destination)\n')
-
     // `match` against the ID shape, which the files plugin builds from the path
     // inside filesFolder — NOT the URL shape.
+    // A five-line plugin in place of the assets pipeline.
+    //
+    // `derived` is `entity.meta.presets`, spread onto the response. What drive
+    // owns is that passthrough — the field name it reads and the field name it
+    // writes. Producing a real derivative to test it meant a live sharp
+    // encode, a preset module on disk, and a hard dependency on
+    // mikser-io-assets for a package that does not otherwise use it; the
+    // assertions it bought beyond the passthrough (a .webp suffix, a URL
+    // unlike the source) are presetUrl's behaviour and are unit-tested in
+    // mikser-io-assets, where changing them would be noticed.
+    //
+    // Stamped in onProcessed, the same hook and the same field the assets
+    // plugin writes.
     await writeFile(path.join(dir, 'mikser.config.js'),
-        "import { files, assets, renderPreset } from 'mikser-io'\n"
+        "import { files } from 'mikser-io'\n"
         + "import { mcp } from 'mikser-io-mcp'\n"
         + "import { drive } from 'mikser-io-drive'\n"
+        // onProcessed is a PHASE hook — it receives the abort signal, not an
+        // entity — so the stamp walks the journal, which is the same shape and
+        // the same hook the assets plugin uses to write this field.
+        + 'const stampPresets = () => ({ onProcessed, useJournal, updateEntity, constants: { OPERATION } }) =>\n'
+        + '    onProcessed(async (signal) => {\n'
+        + "    for await (const { entity } of useJournal('Stamp presets', [OPERATION.CREATE, OPERATION.UPDATE], signal)) {\n"
+        + "        if (entity.collection !== 'files' || !entity.id.endsWith('.png')) continue\n"
+        + "        entity.meta = { ...entity.meta, presets: { web: '/derived/web/shots/hero.webp' } }\n"
+        + '        await updateEntity(entity)\n'
+        + '    }\n'
+        + '})\n'
         + 'export default async () => ({\n'
         + '    plugins: [\n'
         + "        mcp({ base: '' }),\n"
         + "        files({ filesFolder: 'media', outputFolder: 'media' }),\n"
-        + "        assets({ assetsFolder: 'derived', presetsFolder: 'presets',\n"
-        + "                 presets: { web: { match: ['/files/**/*.png'] } } }),\n"
-        + '        renderPreset(),\n'
+        + '        stampPresets(),\n'
         + "        drive({ allowRemote: true, endpoints: { media: { folder: 'media' } } }),\n"
         + '    ],\n'
         + '})\n')
@@ -144,7 +160,7 @@ after(async () => {
     if (dir) await rm(dir, { recursive: true, force: true })
 })
 
-describe('derived — the preset passthrough', { skip: hasSharp ? false : 'sharp is not installed' }, () => {
+describe('derived — the preset passthrough', () => {
     it('reports the variant a preset actually produced', async () => {
         const session = { id: null, n: 1 }
         await rpc(null, 'initialize',

package/test/drive.test.js

@@ -27,7 +27,7 @@ before(async () => {
     await writeFile(path.join(dir, 'users.htpasswd'), ['alice', 'bob', 'carol']
         .map(u => `${u}:${bcrypt.hashSync(`${u}-pw`, 10)}`).join('\n') + '\n')
     await writeFile(path.join(dir, 'groups.htgroup'),
-        'editors: alice\nreviewers: bob\n')
+        'editors: alice\nreviewers: bob\nowners: carol\n')
 
     const { default: express } = await import('express')
     const app = express()
@@ -43,6 +43,10 @@ before(async () => {
             // why `editors` has to name `drive:locked` too.
             editors:   ['drive:content', 'drive:content:write', 'drive:locked'],
             reviewers: ['drive:content'],                          // read, no write
+            // `*` is a real wildcard. It was written in grants long before it
+            // meant anything, and matched nothing — every gate was an exact
+            // includes, including the two in this package.
+            owners:    ['*'],
         },
     })
 
@@ -103,11 +107,30 @@ describe('auth', () => {
     })
 
     it('403s an authenticated user who lacks the endpoint capability', async () => {
-        // carol is in no group, so with a capability map configured she holds
-        // nothing — authenticated, but not for this endpoint.
-        const res = await dav('PROPFIND', '/drive/content/', { headers: { depth: '0', ...as('carol') } })
+        // bob is a reviewer: he holds drive:content but was never granted
+        // drive:locked, so that endpoint is not his to open.
+        const res = await dav('PROPFIND', '/drive/locked/', { headers: { depth: '0', ...as('bob') } })
         assert.equal(res.status, 403)
     })
+
+    it('opens an endpoint for a wildcard holder who was never granted it', async () => {
+        // carol holds `*` and nothing else. The gate here checked
+        // `capabilities.includes(...)` directly rather than asking
+        // hasCapability, so a wildcard reached api and mcp — which declare no
+        // capability and so pass the unscoped check — and stopped at the
+        // drive, which declares one. A role whose summary said "everything"
+        // could not open a folder, and its printed reach was empty.
+        const res = await dav('PROPFIND', '/drive/content/', { headers: { depth: '0', ...as('carol') } })
+        assert.equal(res.status, 207, 'a wildcard holder may mount and read')
+    })
+
+    it('lets a wildcard holder write, without naming the write capability', async () => {
+        const res = await dav('PUT', '/drive/content/wildcard.md', {
+            headers: { ...as('carol'), 'content-type': 'text/markdown' },
+            body: '# by a wildcard holder\n',
+        })
+        assert.ok([201, 204].includes(res.status), `expected a write, got ${res.status}`)
+    })
 })
 
 describe('read and write', () => {

package/test/files.test.js

@@ -4,7 +4,7 @@ import { mkdtemp, rm, mkdir, writeFile, readFile, stat } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 
-import { runtime } from 'mikser-io'
+import { runtime, provideService, resetServices } from 'mikser-io'
 import { registerFileTools } from '../lib/files.js'
 import { readCapability, writeCapability } from '../index.js'
 
@@ -41,8 +41,10 @@ before(async () => {
     runtime.options = { ...runtime.options, workingFolder: dir, runtimeFolder: path.join(dir, 'runtime') }
 
     mcp = fakeSubstrate({ subject: 'alice', capabilities: ['drive:media', 'drive:media:write'] })
+    resetServices()
+    provideService('mcp', mcp)
     registerFileTools({
-        runtime: { options: { ...runtime.options, mcp }, refs: runtime.refs },
+        runtime: { options: { ...runtime.options }, refs: runtime.refs },
         endpoints: { media: { folder: 'media' }, locked: { folder: 'locked', readOnly: true } },
         capabilityOf: readCapability, writeCapabilityOf: writeCapability,
     })
@@ -448,10 +450,12 @@ describe('move', () => {
 describe('read capability', () => {
     const toolsFor = async (principal) => {
         const substrate = fakeSubstrate(principal)
+        resetServices()
+        provideService('mcp', substrate)
         registerFileTools({
             runtime: {
                 options: {
-                    ...runtime.options, mcp: substrate,
+                    ...runtime.options,
                     roles: {
                         catalogue: {
                             editors: ['drive:media', 'drive:media:write', 'drive:secrets'],