slotlock 0.6.1 → 0.6.3

package/self-host.js

@@ -11,7 +11,7 @@ import { createSlotlockAgentServer, slotlockAgentOperationScope, } from './agent
 import { createSlotlockStoreAgentBackend, createSlotlockStoreApplicationBackend, createSlotlockStoreChangeSource, } from './agent-store-backend.js';
 import { SLOTLOCK_API_KEY_DEFAULT_SCOPES, SLOTLOCK_API_KEY_MAX_LIFETIME_DAYS, SLOTLOCK_API_KEY_SCOPES, createSlotlockApiKeyAuthenticator, createSlotlockApiKeyStore, slotlockBearerCredential, } from './api-keys.js';
 import { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockAcceptanceRecords, createSlotlockDashboardState, } from './dashboard.js';
-import { SECRET_HINT, SlotlockConfigError, formatSlotlockRate, optional, readAvailability, readDashboardConfig, readDashboardOrganizations, readLimits, readSecret, readServerUrl, readTrustedProxyHeader, slotlockKeySubscriptions, } from './config.js';
+import { SECRET_HINT, SlotlockConfigError, formatSlotlockRate, optional, readAvailability, readDashboardConfig, readDashboardOrganizations, readDashboardUsers, readLimits, readSecret, readServerUrl, readTrustedProxyHeader, readTrustedProxySecret, slotlockKeySubscriptions, } from './config.js';
 import { parseBookingRules } from './booking-rules.js';
 import { SLOTLOCK_APPLICATION_SCOPE } from './application-api.js';
 import { SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_TENANT_TABLES } from './ddl.js';
@@ -40,6 +40,7 @@ export const SLOTLOCK_ENVIRONMENT_VARIABLES = Object.freeze([
     'SLOTLOCK_SHARED_LIMITS',
     'SLOTLOCK_LIMITS',
     'SLOTLOCK_TRUSTED_PROXY_HEADER',
+    'SLOTLOCK_TRUSTED_PROXY_SECRET',
     'SLOTLOCK_GITHUB_CLIENT_ID',
     'SLOTLOCK_GITHUB_CLIENT_SECRET',
     'SLOTLOCK_SESSION_SECRET',
@@ -64,7 +65,7 @@ const DAY_MS = 86_400_000;
  * every GitHub user gives each a tenant, so the cap keeps one from filling the database.
  */
 const SERVE_MAX_TENANT_RESOURCES = 10_000;
-/** How often `serve` maintains each tenant it serves (README, Operations: at least daily). */
+/** How often `serve` maintains each tenant with data (README, Operations: at least daily). */
 const SERVE_MAINTENANCE_INTERVAL_MS = 60 * 60 * 1_000;
 /** Passes `slotlock maintain` runs at most, each as big as `serve`'s, until nothing is left. */
 const MAINTAIN_MAX_PASSES = 100;
@@ -238,6 +239,9 @@ export function readSlotlockServeConfig(env) {
     const trustedProxyHeader = readTrustedProxyHeader(env);
     if (trustedProxyHeader !== undefined)
         config.trustedProxyHeader = trustedProxyHeader;
+    const trustedProxySecret = readTrustedProxySecret(env, trustedProxyHeader);
+    if (trustedProxySecret !== undefined)
+        config.trustedProxySecret = trustedProxySecret;
     if (authToken !== undefined)
         config.authToken = authToken;
     const metricsToken = readSecret(env, 'SLOTLOCK_METRICS_TOKEN');
@@ -260,6 +264,9 @@ export function readSlotlockServeConfig(env) {
     const organizations = readDashboardOrganizations(env);
     if (organizations !== undefined)
         config.organizations = organizations;
+    const allowedUsers = dashboard?.allowedUsers ?? readDashboardUsers(env);
+    if (allowedUsers !== undefined)
+        config.allowedUsers = allowedUsers;
     if (confirmWrites.length > 0 && confirmationSecret !== undefined) {
         config.confirmationSecret = confirmationSecret;
     }
@@ -313,6 +320,7 @@ function secretsIn(env) {
         'SLOTLOCK_SESSION_SECRET',
         'SLOTLOCK_ASSISTANT_SECRET',
         'SLOTLOCK_METRICS_TOKEN',
+        'SLOTLOCK_TRUSTED_PROXY_SECRET',
     ]) {
         const value = env[name]?.trim();
         if (value)
@@ -499,16 +507,16 @@ function serveMetrics(target, metrics, path, token) {
     };
 }
 /**
- * Whether the dashboard's allowlists let a tenant act: a `github-org:<id>` tenant only while
- * SLOTLOCK_DASHBOARD_ORGS lists that organization, wherever the dashboard runs; otherwise every
- * tenant when there is no dashboard or it allows everyone, and a `github:<id>` tenant only while
- * that id is listed.
+ * Whether the dashboard's allowlists let a tenant act, wherever the dashboard runs: a
+ * `github-org:<id>` tenant only while SLOTLOCK_DASHBOARD_ORGS lists that organization; a
+ * `github:<id>` tenant only while SLOTLOCK_DASHBOARD_USERS is `*` or lists that id; every tenant when
+ * SLOTLOCK_DASHBOARD_USERS is not set, and every other tenant.
  */
-function dashboardAllows(config, tenantRef) {
+export function slotlockServeAllowsTenant(config, tenantRef) {
     const orgId = /^github-org:(\d+)$/.exec(tenantRef)?.[1];
     if (orgId !== undefined)
         return config.organizations?.includes(orgId) === true;
-    const users = config.dashboard?.allowedUsers;
+    const users = config.allowedUsers;
     if (users === undefined || users === '*')
         return true;
     const githubId = /^github:(\d+)$/.exec(tenantRef)?.[1];
@@ -550,6 +558,16 @@ export function createSlotlockMaintenanceStore(sql, caps, options = {}) {
         maxHeldHoursPerHolder: caps.holder_held_hours,
     });
 }
+/** Every tenant a paged SECURITY DEFINER list (1,000 names a page, after the last) returns. */
+async function pageTenants(page) {
+    const tenants = [];
+    for (;;) {
+        const rows = await page(tenants.at(-1) ?? null);
+        tenants.push(...rows.map(({ tenant }) => tenant));
+        if (rows.length < 1_000)
+            return tenants;
+    }
+}
 /** Serve MCP and A2A over HTTP from the Postgres store, as one token-authenticated tenant. */
 export async function startSlotlockServer(config, log) {
     const sql = connect(config.databaseUrl, POOL_SIZE);
@@ -666,13 +684,16 @@ export async function startSlotlockServer(config, log) {
             ...(config.trustedProxyHeader !== undefined
                 ? { trustedProxyHeader: config.trustedProxyHeader }
                 : {}),
+            ...(config.trustedProxySecret !== undefined
+                ? { trustedProxySecret: config.trustedProxySecret }
+                : {}),
             basePath,
             signInPaths: config.dashboard ? ['/dashboard/sign-in', '/dashboard/callback'] : [],
             // The token is compared in constant time first; only then is a key looked up. A person the
             // dashboard no longer allows loses their keys with their session.
             authenticate: async (request) => {
                 const principal = (await authenticateToken?.(request)) ?? (await authenticateKey(request));
-                if (!principal || !dashboardAllows(config, principal.tenantRef))
+                if (!principal || !slotlockServeAllowsTenant(config, principal.tenantRef))
                     return null;
                 maintenance?.touch(principal.tenantRef);
                 return principal;
@@ -811,6 +832,10 @@ export async function startSlotlockServer(config, log) {
             store: createSlotlockMaintenanceStore(sql, caps, retention),
             sql,
             tenants: [config.tenantRef],
+            // Every tenant with data, from the database: one whose keys have not called since this server
+            // started is maintained too. Names only; each pass runs in its tenant's own context.
+            discover: () => pageTenants((after) => sql `
+          SELECT slotlock.maintenance_tenants(${after}::text) AS tenant`),
             intervalMs: SERVE_MAINTENANCE_INTERVAL_MS,
             // Counts only, never the tenant.
             onPass: (result) => {
@@ -824,16 +849,8 @@ export async function startSlotlockServer(config, log) {
             const send = createSlotlockWebhookSender({ allowPrivateNetworks: config.webhooks === 'private' });
             webhooks = startSlotlockWebhookDelivery({
                 // The tenants with a webhook, from the database: a restarted server finds them all.
-                tenants: async () => {
-                    const tenants = [];
-                    for (;;) {
-                        const page = await sql `
-              SELECT slotlock.webhook_tenants(${tenants.at(-1) ?? null}::text) AS tenant`;
-                        tenants.push(...page.map(({ tenant }) => tenant));
-                        if (page.length < 1_000)
-                            return tenants;
-                    }
-                },
+                tenants: () => pageTenants((after) => sql `
+            SELECT slotlock.webhook_tenants(${after}::text) AS tenant`),
                 deliver: (tenantRef) => deliverSlotlockWebhooks({
                     tenantRef,
                     send,
@@ -873,6 +890,7 @@ export async function startSlotlockServer(config, log) {
                 key_subscriptions: slotlockKeySubscriptions(caps),
             },
             client_address: config.trustedProxyHeader ?? 'socket',
+            client_address_proof: config.trustedProxySecret !== undefined,
         });
         return {
             address,
@@ -1226,7 +1244,7 @@ Commands:
   migrate                  Apply the schema and row-level security, then grant the serving
                            role when SLOTLOCK_MIGRATE_DATABASE_URL names another role
   serve [--migrate]        Serve MCP, A2A and REST over HTTP (--migrate runs migrate first);
-                           maintains each tenant it serves every hour
+                           maintains every tenant with data every hour
   maintain                 Run maintenance for the tenant now: extend recurring events to the
                            rolling horizon and prune past the retention window (for cron)
   resource add <ref> [--timezone <IANA zone>]
@@ -1321,6 +1339,9 @@ Environment:
   SLOTLOCK_TRUSTED_PROXY_HEADER  The request field a proxy in front sets to the client address,
                                  such as CF-Connecting-IP (default: the connection's address);
                                  set it only when every request comes through that proxy
+  SLOTLOCK_TRUSTED_PROXY_SECRET  A secret the proxy adds to every request in x-slotlock-proxy-proof,
+                                 32+ random characters: without it there, the field above is
+                                 ignored and the connection's address counts
   SLOTLOCK_GITHUB_CLIENT_ID      Serve the dashboard at $SLOTLOCK_PUBLIC_URL/dashboard: the Client ID
                                  of a GitHub OAuth app with callback .../dashboard/callback
   SLOTLOCK_GITHUB_CLIENT_SECRET  That app's client secret (dashboard)
@@ -1332,7 +1353,7 @@ Environment:
                                  resolves to, a loopback, private, link-local, CGNAT, unique-local
                                  or metadata address; on: allow them, for a self-hosted model
                                  (Ollama, vLLM) on this machine or network
-  SLOTLOCK_DASHBOARD_USERS       * or comma-separated GitHub user ids that may sign in (dashboard)
+  SLOTLOCK_DASHBOARD_USERS       * or comma-separated GitHub user ids that may sign in and whose keys work
   SLOTLOCK_DASHBOARD_ORGS        comma-separated GitHub organization ids: each is one shared tenant
   SLOTLOCK_DASHBOARD_NAME        What the dashboard calls this deployment (default Slotlock)
   HOST                           Listen address (default 127.0.0.1)

package/slotlock.manifest.json

@@ -3,7 +3,7 @@
   "schemaVersion": "1.0",
   "name": "Slotlock",
   "package": "slotlock",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Resource-first, deterministic calendar and availability engine for AI agents.",
   "intervalSemantics": {
     "boundary": "[)",