@jini-ai/server 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## Unreleased
+## 0.5.1 — 2026-10-08
 
 - Align pack contributions, bindings, HTTP mounting, retry classification, executor settings and
   event-log cleanup with the current core/daemon object argument contracts.

package/dist/builtin-features.js

@@ -151,7 +151,10 @@ export function projectDetectedAgent(agent) {
         available: agent.available,
         ...(agent.version !== undefined ? { version: agent.version } : {}),
         ...(agent.authStatus !== undefined ? { authStatus: agent.authStatus } : {}),
-        models: agent.models.map(({ id, label }) => ({ id, label })),
+        models: agent.models.map(({ id, label, identityKind, resolvedId }) => ({ id, label, ...(identityKind ? { identityKind } : {}), ...(resolvedId ? { resolvedId } : {}) })),
+        ...(agent.modelCatalog ? { modelCatalog: agent.modelCatalog } : {}),
+        ...(agent.defaultModelResolution ? { defaultModelResolution: agent.defaultModelResolution } : {}),
+        ...(agent.supportsConcreteModelSelection !== undefined ? { supportsConcreteModelSelection: agent.supportsConcreteModelSelection } : {}),
         ...(agent.reasoningOptions !== undefined
             ? { reasoningOptions: agent.reasoningOptions.map(({ id, label }) => ({ id, label })) }
             : {}),
@@ -241,13 +244,14 @@ export function createBuiltInFeatures(options = {}) {
         compose: (context) => {
             // Promise-cached so concurrent clients never spawn duplicate probe sets; invalidated by
             // POST /api/agents/rescan.
-            const detector = options.agents?.detector ?? (() => detectAgents({}));
+            const detector = options.agents?.detector ?? ((force) => detectAgents({}, { force }));
             let scan = null;
+            let expiresAt = 0;
             const scanAgents = (force) => {
-                if (force)
+                if (force || Date.now() >= expiresAt)
                     scan = null;
                 if (!scan) {
-                    const pending = detector()
+                    const pending = detector(force)
                         // Filtered before projection so the executor's answer is computed from the full def —
                         // see `isExecutableDetectedAgent`'s doc for why the projected shape is not enough.
                         .then((agents) => agents.filter(isExecutableDetectedAgent).map(projectDetectedAgent))
@@ -261,6 +265,7 @@ export function createBuiltInFeatures(options = {}) {
                         throw error;
                     });
                     scan = pending;
+                    expiresAt = Date.now() + 15 * 60_000;
                 }
                 return scan;
             };

package/dist/create-local-node-daemon.d.ts

@@ -6,7 +6,7 @@ import type { Bindings, Principal, ToolRegistration } from '@jini-ai/core';
 import type { AnyPack, MissingTokenIds } from '@jini-ai/core/composition';
 import type { ResolveRunInput, RunLifecycle } from '@jini-ai/daemon';
 import { type AdapterContext } from '@jini-ai/http-kit';
-import { type DelegatedToolExecuteRequest, type RunStartHandler, type WorkspaceRootResolver } from '@jini-ai/daemon/http';
+import type { DelegatedToolExecuteRequest, RunStartHandler, WorkspaceRootResolver } from '@jini-ai/daemon/http';
 import { type JiniKernelSecurity, type KernelBoundIds } from './compose-jini-kernel.js';
 import type { CapabilityId, JiniProfileId } from './feature.js';
 export { buildDaemonDbOperations, projectDetectedAgent } from './builtin-features.js';

package/dist/create-local-node-daemon.js

@@ -33,7 +33,6 @@
 import { createRequire } from 'node:module';
 import express, {} from 'express';
 import { installRouteRegistrationGuard, mountPackHttp } from '@jini-ai/http-kit';
-import {} from '@jini-ai/daemon/http';
 import { removeDaemonRegistryRecordIfCurrent, resolveDaemonRegistryPath, writeDaemonRegistryRecord } from '@jini-ai/sidecar';
 import { composeJiniKernel } from './compose-jini-kernel.js';
 import { closeHttpServer, normalizeDaemonBindHost } from './host-bootstrap.js';

package/dist/index.d.ts

@@ -1,141 +1,34 @@
 /**
  * @module @jini-ai/server
  *
- * The Node.js host preset (extraction-plan.md §2.4): `createLocalNodeDaemon`, the piece that
- * assembles `@jini-ai/core`/`@jini-ai/daemon`/concern-owned storage adapters/`@jini-ai/http-kit` into an actually-runnable
- * daemon process, plus the generic host-lifecycle primitives it's built on. See `archived provenance ledger`
- * for full provenance and scope-decision notes.
-
- * Archived provenance rationale:
- * ## Design decisions
- *
- * **1. Two function overloads instead of one generic signature with a defaulted `BoundIds`.** The
- * task brief's literal shown signature was
- * `createLocalNodeDaemon<const Packs, BoundIds extends string = KernelBoundIds>(config: ...)`.
- * Empirically verified against this repo's TypeScript (5.9.3, `strict`) that this shape does not
- * actually preserve `createDaemon`'s compile-time "missing binding" gate: when a type parameter both
- * has a default *and* is referenced inside a conditional type in the same position where it also
- * needs inference from a nested callback's return type, TypeScript resolves it to the default
- * instead of inferring from the callback — silently defeating the gate on exactly the call shape
- * (`bindings` customizer provided) where it matters most. Fixed by splitting into two overloads — one
- * where `bindings` is absent and `BoundIds` is the concrete `KernelBoundIds`, one where `bindings` is
- * required and `BoundIds` is inferred fresh with no default — which sidesteps the inference conflict
- * entirely. Both directions (and an under-binding customizer, and a satisfied customizer) are proven
- * in `create-local-node-daemon.typecheck.ts`. Documented in full inline on the exported function.
- *
- * **2. `resolveBoundPort`/`resolveReportHost` extracted as small pure, exported helpers.** The
- * origin's `.listen()` tail inlined both the "is `server.address()` actually usable" check and the
- * "substitute 127.0.0.1 for an all-interfaces bind host" substitution directly in the `'listening'`
- * callback. Pulling them out makes two genuinely-defensive branches (a `server.address()` that is
- * `null`/a Unix-socket-path string/a non-positive port — provably unreachable via any real TCP
- * listener once `'listening'` has fired, per the origin's own "belt-and-braces" framing) directly
- * unit-testable without mocking Express or the underlying socket at all.
- *
- * **3. `@jini/core/internal`'s `AnyPack`/`RequiredTokenIds`/`MissingTokenIds` re-export.** Needed so
- * this package could re-derive `createDaemon`'s exact compile-time gate rather than duplicate the
- * type-level logic. See `packages/core/src/internal.ts`'s own module doc and
- * `packages/core/src/daemon.ts` — these three types are now `export`ed there (previously
- * module-private) but deliberately *not* re-exported from `@jini/core`'s public `index.ts` (which
- * switched from a `daemon.js` wildcard re-export to an explicit named list for exactly this reason).
- *
- * **4. `createDaemon`'s own compile-time gate is bypassed (via a cast) inside
- * `createLocalNodeDaemon`'s implementation body**, the same way
- * `packages/core/src/__tests__/index.test.ts`'s `createDaemonUnsafe` reaches `createDaemon`'s runtime
- * path directly: `Packs`/`BoundIds` are still abstract, unresolved type parameters inside a generic
- * function body, so `createDaemon`'s own conditional gate can never collapse to a definite branch
- * there regardless of which overload the real call site matched. Safety was already established by
- * this function's own equivalent gate (present on both exported overloads) at the real call site.
- *
- * **5. `stop()` always closes the durable `EventLog`, even when the caller's `onShutdown` hook
- * rejects** — `try { await config.onShutdown?.() } finally { await eventLog.close() }` — so a
- * caller-supplied hook failing can never leak an open sqlite file handle; the original rejection
- * still propagates to whoever awaited `stop()`.
- *
- * **6. `env[JINI_BIND_HOST]` is set before serving any request — a documented, only-partially-fixable
- * wrinkle.** `@jini/http`'s own `guardSameOrigin` (used by `registerDaemonStatusRoutes`' shutdown
- * route) resolves `bindHost` purely from real `process.env.JINI_BIND_HOST`, with **no parameter path**
- * of its own — unlike most of that module's other functions, it never accepts an injected `env`.
- * `createLocalNodeDaemon` sets `env[JINI_BIND_HOST] = host` (where `env` is `config.env ??
- * process.env`) before returning, which correctly fixes the common case (no `env` override — the
- * default, real `process.env` gets the right value). When a caller *does* inject a distinct `env`
- * object for full test isolation, this line cannot make `guardSameOrigin`'s hardwired real-`process.env`
- * read reflect it — a pre-existing `@jini/http` limitation this call cannot reach around without
- * editing `origin.ts` itself (out of scope here, same reasoning as the origin-validation duplication
- * flagged in `packages/http/archived provenance ledger`).
- *
- * ## 2026-07-29 — post-merge audit fixes (six teardown/config/URL defects)
- *
- * Independent review of the `feat/agentic-capability-layer` merge (OpenAI Codex `gpt-5.6-sol` as peer
- * reviewer, then re-verified against source here) surfaced six real defects in this package. Each was
- * reproduced with a failing test before any fix landed.
- *
- * **1. Caller packs were never disposed.** `composeJiniKernel` calls `createDaemon` on `config.packs`,
- * so it — not the caller — builds their services; but neither the failure-cleanup path nor `close()`
- * ever ran their `dispose`. A caller pack whose `services()` opened a socket, timer or database handle
- * leaked it past `createLocalNodeDaemon().stop()`, and the wrapper exposes no caller daemon for the
- * host to tear down itself. Added `JiniKernel.disposeCallerPacks()` — memoized, best-effort, symmetric
- * with `disposeFeatures()` — called by `close()`, by the composition-failure `catch`, and by the
- * daemon's `stop()`. Disposal order is reverse of construction: features first (they were composed
- * against an already-built caller daemon), caller packs second.
- *
- * **2. `journal.db` opened outside the cleanup block.** `createJiniKernelBase` opened `events.db`, then
- * `journal.db`, and only *then* entered the `try` whose `catch` closed them. `journal.db` failing (a
- * corrupt file, or a directory sitting where a database was expected) left the `events.db` handle open
- * in a process that has no kernel. Every acquisition now happens inside the one block, tracked in an
- * `opened` array the cleanup drains — the shape the module's own comment already claimed.
- *
- * **3. Capability keys were not runtime-validated.** Feature ids in `config.features` threw on a typo;
- * capability ids in `config.capabilities` did not. `{'host:exce': false}` deleted a grant nobody held,
- * so `host:exec` survived and `terminal`/`hostTools` stayed mounted — a security switch that fails
- * *open* on a typo, in the direction that reads as applied. `feature.ts` now carries the runtime half
- * of `CapabilityId` as a `Record<CapabilityId, true>` (drift is a compile error in both directions, so
- * the list cannot silently fall behind the union it validates) plus `CAPABILITY_IDS`/`isCapabilityId`;
- * `resolveFeatureActivation` validates the keys next to where it validates feature ids.
- *
- * **4. An injected `config.env` never reached the per-route same-origin guard.** `env[JINI_BIND_HOST] =
- * host` writes into the caller's object when one is supplied, and `@jini-ai/http-kit`'s `guardSameOrigin`
- * read real `process.env`. The origin-guard *middleware* was already handed the injected `env`, so the
- * two halves of one decision read two different environments: the middleware admitted an origin the
- * host configured through `config.env` and the route then rejected it. Fixed at the seam —
- * `OriginContext` (and so `AdapterContext`) grew an optional `env`, defaulting to `process.env`, and
- * this preset sets it. That covers `JINI_BIND_HOST`, `JINI_ALLOWED_ORIGINS` and `JINI_WEB_PORT` alike.
- *
- * **5. Shutdown could skip its own teardown, or crash the process.** `closeHttpServer` rejecting (which
- * its own contract documents) skipped feature disposal, discovery-record removal, `onShutdown` and the
- * sqlite close — leaving a half-torn-down daemon, strictly worse than the failure that caused it. It is
- * a `try`/`finally` now; the original rejection still propagates once teardown finishes. Separately,
- * `requestShutdown` dropped `stop()`'s promise with a bare `void`, so a failing shutdown became an
- * unhandled rejection — which on Node's default policy terminates the process this was gracefully
- * shutting down. It is reported through `console.error` now; the rejection stays on `stopPromise` so an
- * explicit `stop()` caller still observes it.
- *
- * **6. `resolveReportHost` produced an unparseable URL for an IPv6 bind host.** `'::1'` passed through
- * unchanged, so the reported base URL was `http://::1:54321` — which `new URL()` and `fetch` both
- * reject, and which was written verbatim into the discovery record. It now returns the bracketed
- * authority form (RFC 3986 §3.2.2), idempotently.
- *
- * Two lower-severity items from the same review, also fixed:
- *
- * - **`agents`' scan cache was not keyed by promise identity.** A slow scan that failed *after* `POST
- *   /api/agents/rescan` had already replaced it with a successful one cleared the newer entry, forcing
- *   a duplicate probe of every agent CLI on the machine. The `catch` now clears only its own entry.
- * - **`createFrontendControl`'s bind boundary did not cover `resolveBindToken` or its own error sink.**
- *   A `RunStartHandler` throwing is not a no-op — `@jini-ai/http-kit`'s run-start route marks the run
- *   `failed` and answers 500 — so a host-supplied `resolveBindToken` throwing (it parses an opaque host
- *   blob) produced exactly the killed run the `onBindError` doc promises never to cause. Both are inside
- *   the boundary now; a throwing sink is swallowed, because the reporting channel is what failed.
- *
- * **One pre-existing gap closed while here.** The package's committed 100% function-coverage gate was
- * already failing on `main` (99.09%): `sidecar-strict`'s origin-guard `getResolvedPort` closure had no
- * end-to-end coverage, because both of that mode's gates are request-time middleware. Added six real
- * `security: sidecar-strict` tests (unauthenticated 401, authenticated 201, cross-origin 403 with a
- * valid token, unset-token 503, probe routes reachable tokenless, `exemptPaths`) — the one block in
- * `compose-jini-kernel.test.ts` that opens a socket, and only because it has to.
- *
- * **Verified, personally, this session**: `packages/server` **231/231 passing** across 8 files (was
- * 215 before the sidecar-strict block), **100/100/100/100 coverage**; `packages/http-kit` 1245/1245 and
- * 100% ; `packages/chat-core` 261/261; `packages/chat-react` 610/610 and 100%;
- * `examples/reference-web` 41/41. Repo-wide `pnpm typecheck` and `pnpm guard` clean.
+ * Node host preset: createLocalNodeDaemon assembles core, daemon, concern-owned
+ * storage and http-kit into a listening service. composeJiniKernel is the same
+ * composition core for hosts mounting their own app without a second listener.
+ *
+ * Composition and lifecycle invariants:
+ * - The preset's two overloads preserve the missing-binding type gate: defaulted
+ *   BoundIds would defeat inference from a custom bindings callback. Core's
+ *   internal token-gate types are reused, rather than reimplemented. The cast
+ *   inside the generic body is protected by both exported overloads' gate.
+ * - resolveBoundPort and resolveReportHost are pure helpers so defensive address
+ *   checks are directly testable without a listener. Wildcard hosts are reported
+ *   as loopback and IPv6 authorities are bracketed so discovery URLs are usable.
+ * - Resource acquisition stays inside cleanup boundaries so a later database
+ *   open cannot leak an earlier handle. Features dispose before caller packs,
+ *   reversing construction; the preset constructed those services and owns
+ *   teardown. Listener-close or onShutdown failures cannot skip storage close,
+ *   feature disposal or discovery removal. Explicit stop callers observe failures;
+ *   requested shutdown failures are reported rather than dropped as rejections.
+ * - Feature and capability keys are runtime-validated: silently accepting a typo
+ *   in a disabled capability would leave the real security-sensitive grant active.
+ * - Bind-host configuration is set before serving requests. The injected env is
+ *   shared with origin middleware and route guards so both enforce the same policy.
+ * - Agent scan cache cleanup checks promise identity so an older failed scan
+ *   cannot clear its replacement. Frontend binding contains resolver and error-sink
+ *   failures so a host binding error cannot fail the underlying run.
+ *
+ * Frontend control belongs to daemon/http; this entry retains its public forwarding
+ * exports. See owning modules and packages/server/README.md for detailed contracts.
  */
 export type { CreateLocalNodeDaemonConfig, KernelBoundIds, LocalNodeDaemon, LocalNodeHttpExtension, LocalNodeHttpExtensionContext, } from './create-local-node-daemon.js';
 export { buildDaemonDbOperations, classifyRunFailureForRetry, createLocalNodeDaemon, projectDetectedAgent, resolveBoundPort, resolveReportHost, } from './create-local-node-daemon.js';

package/dist/kernel-base.js

@@ -70,8 +70,8 @@ export async function createJiniKernelBase(options) {
         if (sqliteStorage && eventsDbPath !== null && dataDir !== null) {
             // A *second* connection to the same `events.db` the log above owns — safe: both run in WAL
             // mode, which permits multiple concurrently open handles on one file within a single process.
-            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open(file, settings) {
-                    featureConnection = sqliteStorage.open(file, settings);
+            featureConnection = openSqliteConnection({ filePath: eventsDbPath, open({ filePath }, settings) {
+                    featureConnection = sqliteStorage.open(filePath, settings);
                     return featureConnection;
                 } });
             sqlite = { connection: featureConnection, eventsDbPath, dataDir };

package/dist/storage/legacy/sqlite.js

@@ -39,7 +39,7 @@ export function openDatabase({ projectRoot, open }, options = {}) {
     (options.filesystem ?? fs).mkdirSync(dir, { recursive: true });
     let db;
     try {
-        db = openSqliteConnection({ filePath: file, open(file, settings) { db = open(file, settings); return db; }, pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
+        db = openSqliteConnection({ filePath: file, open({ filePath }, settings) { db = open(filePath, settings); return db; } }, { pragmas: ['journal_mode = WAL', 'foreign_keys = ON'] });
         migrate({ db });
         dbInstance = db;
         dbFile = file;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/server",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -11,7 +11,12 @@
     "domain": "server",
     "kind": "host",
     "runtime": "node",
-    "admission": "locked"
+    "admission": "locked",
+    "isolation": {
+      "entries": {
+        "./store/projects/sqlite": "storage"
+      }
+    }
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -54,35 +59,68 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "dependencies": {
-    "express": "^4.21.0",
-    "@jini-ai/agent-runtime": "0.4.0",
-    "@jini-ai/core": "0.4.0",
-    "@jini-ai/http-kit": "0.4.0",
-    "@jini-ai/daemon": "0.5.0",
-    "@jini-ai/sidecar": "0.4.0",
-    "@jini-ai/db": "0.2.0",
-    "@jini-ai/registry": "0.5.0",
-    "@jini-ai/chat": "0.5.0"
-  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
     "@types/express": "^4.17.21",
     "@vitest/coverage-v8": "^2.1.9",
-    "better-sqlite3": "^13.0.0"
+    "better-sqlite3": "^13.0.0",
+    "express": "^4.21.0",
+    "@jini-ai/core": "0.4.2",
+    "@jini-ai/http-kit": "0.4.1",
+    "@jini-ai/daemon": "0.5.4",
+    "@jini-ai/agent-runtime": "0.4.2",
+    "@jini-ai/sidecar": "0.4.1",
+    "@jini-ai/db": "0.3.1",
+    "@jini-ai/chat": "0.5.5",
+    "@jini-ai/registry": "0.5.2"
+  },
+  "dependencies": {
+    "@jini-ai/core": "^0.4.2"
   },
   "peerDependencies": {
-    "better-sqlite3": "^13.0.0"
+    "better-sqlite3": "^13.0.0",
+    "@jini-ai/agent-runtime": "^0.4.1",
+    "@jini-ai/daemon": "^0.5.4",
+    "@jini-ai/http-kit": "^0.4.0",
+    "@jini-ai/sidecar": "^0.4.0",
+    "express": "^4.21.0",
+    "@jini-ai/db": "^0.3.0",
+    "@jini-ai/chat": "^0.5.4",
+    "@jini-ai/registry": "^0.5.1"
   },
   "peerDependenciesMeta": {
     "better-sqlite3": {
       "optional": true
+    },
+    "@jini-ai/agent-runtime": {
+      "optional": true
+    },
+    "@jini-ai/daemon": {
+      "optional": true
+    },
+    "@jini-ai/http-kit": {
+      "optional": true
+    },
+    "@jini-ai/sidecar": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "@jini-ai/db": {
+      "optional": true
+    },
+    "@jini-ai/chat": {
+      "optional": true
+    },
+    "@jini-ai/registry": {
+      "optional": true
     }
   },
   "sideEffects": false,
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "tsc -p tsconfig.tests.json && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.tests.json && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage"
   }