@undefineds.co/xpod 0.4.20 → 0.4.27

package/dist/api/tasks/TaskService.d.ts

@@ -9,6 +9,8 @@ import { type TaskRecordData, type TaskStore } from './store';
 import type { AiConnectionsInvocationKeyIssuer } from '../ai-gateway/auth/AiConnectionsInvocationKeyIssuer';
 export interface CreateTaskInput {
     title?: string;
+    assignedTo?: string;
+    source?: string;
     prompt: string;
     workspace: WorkspaceRef;
     runner?: string;
@@ -39,6 +41,32 @@ export declare class TaskService<TContext = StoreContext> {
     createTask(input: CreateTaskInput, context: TContext): Promise<CreateTaskResult>;
     loadTask(taskId: string, context: TContext): Promise<TaskRecordData>;
     listTasks(context: TContext): Promise<TaskRecordData[]>;
+    createTodo(input: {
+        prompt: string;
+        workspace: WorkspaceRef;
+        assignedTo: string;
+        dueAt?: number;
+        notes?: string;
+        priority?: string;
+        source?: string;
+    }, context: TContext): Promise<TaskRecordData>;
+    updateTodo(id: string, owner: string, input: {
+        completed?: boolean;
+        dueAt?: number | null;
+        notes?: string;
+        priority?: string;
+    }, context: TContext): Promise<TaskRecordData>;
+    setSchedulePaused(id: string, paused: boolean, context: TContext): Promise<TaskRecordData>;
+    runNow(id: string, context: TContext): Promise<MaterializedTaskRun>;
+    resumeApprovedRun(input: {
+        runId: string;
+        approval: string;
+        owner: string;
+    }, context: TContext, resolveExecutionContext?: (task: TaskRecordData, caller: TContext) => Promise<TContext | undefined>): Promise<{
+        duplicate?: boolean | undefined;
+        run: import("../runs/store").RunRecordData;
+        resumed: boolean;
+    }>;
     materializeDueTasks(context: TContext, options?: {
         now?: number;
         limit?: number;
@@ -53,7 +81,4 @@ export declare class TaskService<TContext = StoreContext> {
     private normalizeAuthBinding;
     private initialNextRunAt;
     private parseRunnerMetadata;
-    private resolveThreadResource;
-    private resolvePodBaseUrl;
-    private resolveWebId;
 }

package/dist/api/tasks/TaskService.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskService = void 0;
+const TaskResumeDiagnostics_1 = require("./TaskResumeDiagnostics");
+const RunApproval_1 = require("../runs/RunApproval");
+const RunCancellation_1 = require("../runs/RunCancellation");
+const cron_1 = require("./cron");
+const TaskAgentBinding_1 = require("./TaskAgentBinding");
 const types_1 = require("../chatkit/types");
 const store_1 = require("../runs/store");
 const types_2 = require("../workspace/types");
@@ -38,17 +43,19 @@ class TaskService {
             taskId,
             title: input.title,
             workspace: input.workspace,
-            runner: input.runner ?? 'pi:pi',
+            runner: input.runner ?? TaskAgentBinding_1.DEFAULT_TASK_AGENT.runner,
             metadata: input.metadata,
             context,
         });
         const task = {
             id: taskId,
             title: input.title,
+            assignedTo: input.assignedTo ?? TaskAgentBinding_1.DEFAULT_TASK_AGENT.iri,
+            source: input.source,
             prompt: input.prompt,
-            thread: this.resolveThreadResource(thread, context),
+            thread: thread.id,
             workspace: input.workspace,
-            runner: input.runner ?? 'pi:pi',
+            runner: input.runner ?? TaskAgentBinding_1.DEFAULT_TASK_AGENT.runner,
             status: schema_1.TaskStatus.ACTIVE,
             triggerKind,
             cron: input.cron,
@@ -83,6 +90,131 @@ class TaskService {
     async listTasks(context) {
         return this.store.listTasks({}, context);
     }
+    async createTodo(input, context) {
+        if (!input.prompt.trim() || !(0, types_2.isWorkspaceRef)(input.workspace)) {
+            throw new Error('Task instruction and workspace are required');
+        }
+        const now = (0, types_1.nowTimestamp)();
+        const task = {
+            id: (0, store_2.generateTaskResourceId)((0, types_1.generateId)('task')), title: input.prompt.trim(),
+            ...input, prompt: input.prompt.trim(), thread: '', runner: '',
+            triggerKind: schema_1.TaskTriggerKind.ONCE, status: schema_1.TaskStatus.OPEN,
+            createdAt: now, updatedAt: now,
+        };
+        await this.store.saveTask(task, context);
+        return task;
+    }
+    async updateTodo(id, owner, input, context) {
+        const task = await this.store.loadTask(id, context);
+        if (task.assignedTo !== owner)
+            throw new Error('Only your own todo can be edited here');
+        if (input.completed !== undefined) {
+            task.status = input.completed ? schema_1.TaskStatus.COMPLETED : schema_1.TaskStatus.OPEN;
+            task.completedAt = input.completed ? (0, types_1.nowTimestamp)() : undefined;
+        }
+        if (input.dueAt !== undefined)
+            task.dueAt = input.dueAt ?? undefined;
+        if (input.notes !== undefined)
+            task.notes = input.notes;
+        if (input.priority !== undefined)
+            task.priority = input.priority;
+        task.updatedAt = (0, types_1.nowTimestamp)();
+        await this.store.saveTask(task, context);
+        return task;
+    }
+    async setSchedulePaused(id, paused, context) {
+        const task = await this.store.loadTask(id, context);
+        if (!task.authBinding || task.triggerKind === schema_1.TaskTriggerKind.ONCE)
+            throw new Error('Task has no recurring schedule');
+        if (task.status !== schema_1.TaskStatus.ACTIVE && task.status !== schema_1.TaskStatus.BLOCKED)
+            throw new Error('Task has ended');
+        task.status = paused ? schema_1.TaskStatus.BLOCKED : schema_1.TaskStatus.ACTIVE;
+        const now = (0, types_1.nowTimestamp)();
+        if (!paused) {
+            if (task.triggerKind === schema_1.TaskTriggerKind.CRON)
+                task.nextRunAt = (0, cron_1.nextCronOccurrence)(task.cron ?? '', now);
+            if (task.triggerKind === schema_1.TaskTriggerKind.INTERVAL)
+                task.nextRunAt = now + (task.intervalSeconds ?? 0);
+        }
+        task.updatedAt = now;
+        await this.store.saveTask(task, context);
+        return task;
+    }
+    async runNow(id, context) {
+        const task = await this.store.loadTask(id, context);
+        if (!task.authBinding || ![schema_1.TaskStatus.ACTIVE, schema_1.TaskStatus.BLOCKED].includes(task.status))
+            throw new Error('Only scheduled AI tasks can run');
+        return this.materializer.materialize({ task, context, trigger: { kind: 'manual' }, background: true });
+    }
+    async resumeApprovedRun(input, context, resolveExecutionContext) {
+        const run = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('run_read', () => this.store.loadRun(input.runId, context));
+        const approval = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('approval_validation', async () => {
+            const approval = await this.store.readTaskApproval?.(input.approval, context);
+            if (!approval || !['approved', 'rejected'].includes(approval.status)
+                || approval.decisionBy !== input.owner || (approval.assignedTo && approval.assignedTo !== input.owner) || !approval.resolvedAt
+                || approval.thread !== run.thread)
+                throw new Error('Approval does not authorize this run');
+            return approval;
+        });
+        const threadRef = (0, types_1.toThreadRef)({ thread_id: run.thread });
+        const output = JSON.stringify({ kind: 'approval_decision', approval: input.approval, decision: approval.status, actionExecuted: false });
+        const waiting = run.metadata?.waitingTool;
+        // Bind the checkpoint to this Run through the durable waiting-tool receipt. The receipt
+        // lives on the Run row, independent of the client_tool_call item's free-form metadata;
+        // `metadata.runId` remains only as a fallback for runs that predate the receipt.
+        const item = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('checkpoint_validation', async () => {
+            const items = await this.store.loadThreadItems(threadRef, undefined, 1000, 'asc', context);
+            const item = items.data.find(item => item.type === 'client_tool_call' && item.call_id === approval.toolCallId
+                && (waiting?.itemId !== undefined ? item.id === waiting.itemId : item.metadata?.runId === run.id));
+            if (!item || item.type !== 'client_tool_call' || item.name !== approval.toolName)
+                throw new Error('Approval does not match the pending tool checkpoint');
+            return item;
+        });
+        const atCheckpoint = waiting?.itemId === item.id && waiting.requestId === approval.toolCallId;
+        if (item.status === 'completed' && item.output === output) {
+            if (approval.status === 'rejected' && atCheckpoint && run.status === 'waiting_input') {
+                const cancelled = await (0, RunCancellation_1.cancelRun)({ store: this.store, runId: run.id, context, resourceIri: () => run.id });
+                return { run: cancelled, resumed: false, duplicate: true };
+            }
+            if (run.status === 'cancelled')
+                await (0, RunApproval_1.updateRunApprovalSession)(this.store, run, 'completed', context);
+            return { run, resumed: false, duplicate: true };
+        }
+        await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('approval_validation', async () => {
+            if (approval.expiresAt && new Date(approval.expiresAt).getTime() <= Date.now())
+                throw new Error('Approval has expired');
+        });
+        await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('checkpoint_validation', async () => {
+            if (run.status !== 'waiting_input' || waiting?.itemId !== item.id || waiting.requestId !== approval.toolCallId)
+                throw new Error('Run is not waiting at this approval checkpoint');
+        });
+        if (approval.status === 'rejected') {
+            await this.store.saveItem(threadRef, { ...item, status: 'completed', output, metadata: { ...item.metadata, approval: input.approval } }, context);
+            const cancelled = await (0, RunCancellation_1.cancelRun)({ store: this.store, runId: run.id, context, resourceIri: () => run.id });
+            return { run: cancelled, resumed: false };
+        }
+        // Foreground Chat resumes with the authenticated caller. Scheduled Task runs
+        // must still restore their separately granted execution credential.
+        let execution = context;
+        if (run.task) {
+            const task = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('task_lookup', async () => {
+                const tasks = await this.store.listTasks({}, context);
+                const task = tasks.find(task => task.id === run.task);
+                if (!task)
+                    throw new Error('Task not found for this run');
+                return task;
+            });
+            const granted = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('task_auth_restore', async () => {
+                const granted = await resolveExecutionContext?.(task, context);
+                if (!granted)
+                    throw new Error('Agent execution credential is unavailable');
+                return granted;
+            });
+            execution = granted;
+        }
+        const resumed = await this.materializer.resumeClientToolOutput(run, item.id, output, input.approval, execution);
+        return { run: await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('run_result_read', () => this.store.loadRun(run.id, context)), resumed, ...(!resumed ? { duplicate: true } : {}) };
+    }
     async materializeDueTasks(context, options = {}) {
         const now = options.now ?? (0, types_1.nowTimestamp)();
         const dueTasks = await this.store.listTasks({
@@ -153,11 +285,13 @@ class TaskService {
         if (!input.authBinding) {
             throw new Error('Task auth binding is required');
         }
-        if (triggerKind === schema_1.TaskTriggerKind.INTERVAL && (!input.intervalSeconds || input.intervalSeconds <= 0)) {
+        if (triggerKind === schema_1.TaskTriggerKind.INTERVAL && (!input.intervalSeconds || !Number.isFinite(input.intervalSeconds) || input.intervalSeconds <= 0)) {
             throw new Error('intervalSeconds must be a positive number for interval tasks');
         }
-        if (triggerKind === schema_1.TaskTriggerKind.CRON && !input.cron?.trim()) {
-            throw new Error('cron is required for cron tasks');
+        if (triggerKind === schema_1.TaskTriggerKind.CRON) {
+            if (!input.cron?.trim())
+                throw new Error('cron is required for cron tasks');
+            (0, cron_1.nextCronOccurrence)(input.cron, (0, types_1.nowTimestamp)());
         }
         if (triggerKind === schema_1.TaskTriggerKind.EVENT && !input.eventName?.trim()) {
             throw new Error('eventName is required for event tasks');
@@ -177,10 +311,10 @@ class TaskService {
     }
     initialNextRunAt(input, triggerKind, now) {
         if (triggerKind === schema_1.TaskTriggerKind.INTERVAL) {
-            return input.startAt ?? now;
+            return input.startAt ?? now + input.intervalSeconds;
         }
         if (triggerKind === schema_1.TaskTriggerKind.CRON) {
-            return input.startAt ?? now;
+            return input.startAt ?? (0, cron_1.nextCronOccurrence)(input.cron, now);
         }
         return undefined;
     }
@@ -191,42 +325,6 @@ class TaskService {
             type: type || 'pi',
         };
     }
-    resolveThreadResource(thread, context) {
-        const podBaseUrl = this.resolvePodBaseUrl(context);
-        if (podBaseUrl) {
-            if (thread.id.includes('#') && !thread.id.startsWith('#')) {
-                return (0, store_1.resolveDataResource)(podBaseUrl, thread.id);
-            }
-            return (0, store_1.resolveDataResource)(podBaseUrl, `task/${(0, store_1.extractResourceLocalId)(thread.parent ?? thread.id)}/index.ttl#${thread.id}`);
-        }
-        const parentKey = (0, store_1.extractResourceLocalId)(thread.parent ?? thread.id);
-        return `urn:xpod:thread:task:${encodeURIComponent(parentKey)}:${encodeURIComponent(thread.id)}`;
-    }
-    resolvePodBaseUrl(context) {
-        const webId = this.resolveWebId(context);
-        if (!webId) {
-            return undefined;
-        }
-        try {
-            const url = new URL(webId);
-            url.hash = '';
-            url.search = '';
-            const normalizedPath = url.pathname.replace(/\/+$/, '');
-            if (!normalizedPath.endsWith('/profile/card')) {
-                return undefined;
-            }
-            const podPath = normalizedPath.slice(0, -'/profile/card'.length) || '/';
-            url.pathname = podPath;
-            return url.toString().replace(/\/$/, '');
-        }
-        catch {
-            return undefined;
-        }
-    }
-    resolveWebId(context) {
-        const auth = context.auth;
-        return typeof auth?.webId === 'string' ? auth.webId : undefined;
-    }
 }
 exports.TaskService = TaskService;
 //# sourceMappingURL=TaskService.js.map

package/dist/api/tasks/cron.d.ts

@@ -0,0 +1,2 @@
+/** Five-field numeric cron in the execution environment's local timezone. */
+export declare function nextCronOccurrence(expression: string, after: number): number;

package/dist/api/tasks/cron.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextCronOccurrence = nextCronOccurrence;
+/** Five-field numeric cron in the execution environment's local timezone. */
+function nextCronOccurrence(expression, after) {
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5)
+        throw new Error('Cron requires five fields: minute hour day month weekday');
+    const parsed = fields.map((field, index) => parseField(field, [0, 0, 1, 1, 0][index], [59, 23, 31, 12, 7][index]));
+    if (parsed[4].has(7))
+        parsed[4].add(0);
+    const dayWildcard = fields[2].startsWith('*');
+    const weekWildcard = fields[4].startsWith('*');
+    const date = new Date((Math.floor(after / 60) + 1) * 60000);
+    const end = new Date(date);
+    end.setFullYear(end.getFullYear() + 5);
+    while (date < end) {
+        const day = parsed[2].has(date.getDate());
+        const weekday = parsed[4].has(date.getDay());
+        const dayMatches = dayWildcard ? weekday : weekWildcard ? day : day || weekday;
+        if (!parsed[3].has(date.getMonth() + 1) || !dayMatches) {
+            date.setDate(date.getDate() + 1);
+            date.setHours(0, 0, 0, 0);
+            continue;
+        }
+        if (parsed[1].has(date.getHours()) && parsed[0].has(date.getMinutes()))
+            return date.getTime() / 1000;
+        date.setTime(date.getTime() + 60000);
+    }
+    throw new Error('Cron has no occurrence in the next five years');
+}
+function parseField(field, min, max) {
+    const values = new Set();
+    for (const part of field.split(',')) {
+        const match = /^(\*|\d+(?:-\d+)?)(?:\/(\d+))?$/.exec(part);
+        if (!match)
+            throw new Error('Unsupported cron field');
+        const step = Number(match[2] ?? 1);
+        if (!Number.isInteger(step) || step < 1 || step > max + 1)
+            throw new Error('Invalid cron step');
+        const range = match[1] === '*' ? [min, max] : match[1].split('-').map(Number);
+        const start = range[0];
+        const end = range[1] ?? (match[2] ? max : start);
+        if (start < min || end > max || start > end)
+            throw new Error('Cron field is out of range');
+        for (let value = start; value <= end; value += step)
+            values.add(value);
+    }
+    return values;
+}
+//# sourceMappingURL=cron.js.map

package/dist/api/tasks/schema.d.ts

@@ -9,6 +9,9 @@ export declare const Task: import("@undefineds.co/drizzle-solid/dist/core/schema
     workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
     status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     priority: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    dueAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    completedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    notes: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
     assignedTo: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     source: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;

package/dist/api/tasks/store.d.ts

@@ -1,3 +1,5 @@
+import type { RunApprovalStore } from '../runs/RunApproval';
+import type { ApprovalRow } from '@undefineds.co/models';
 import type { WorkspaceRef } from '../workspace/types';
 import type { TaskAuthBindingSnapshot } from './TaskAuthBinding';
 import type { TaskStatusType, TaskTriggerKindType } from './schema';
@@ -5,6 +7,12 @@ export interface TaskRecordData {
     /** Base-relative Solid resource id, e.g. `index.ttl#task_x`. */
     id: string;
     title?: string;
+    assignedTo?: string;
+    source?: string;
+    dueAt?: number;
+    completedAt?: number;
+    notes?: string;
+    priority?: string;
     prompt: string;
     thread: string;
     workspace: WorkspaceRef;
@@ -28,7 +36,8 @@ export interface TaskListOptions {
     dueAt?: number;
     limit?: number;
 }
-export interface TaskStore<TContext> {
+export interface TaskStore<TContext> extends RunApprovalStore<TContext> {
+    readTaskApproval?(iri: string, context: TContext): Promise<ApprovalRow | null>;
     saveTask(task: TaskRecordData, context: TContext): Promise<void>;
     loadTask(taskId: string, context: TContext): Promise<TaskRecordData>;
     listTasks(options: TaskListOptions, context: TContext): Promise<TaskRecordData[]>;

package/dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.d.ts

@@ -1,8 +1,11 @@
 import { CredentialsExtractor, type Credentials, type HttpRequest, type TargetExtractor } from '@solid/community-server';
 /**
- * CSS-compatible DPoP credential extractor that admits one configured HTTP
+ * CSS-compatible Solid credential extractor that admits one configured HTTP
  * loopback IP origin without weakening any access-token or DPoP checks.
  *
+ * Both schemes use routed caches so issuer, JWKS and WebID reads can reach
+ * the runtime's socket-only canonical origin.
+ *
  * HTTPS and localhost deployments keep using the upstream verifier unchanged.
  */
 export declare class ConfiguredLoopbackDPoPWebIdExtractor extends CredentialsExtractor {
@@ -13,6 +16,8 @@ export declare class ConfiguredLoopbackDPoPWebIdExtractor extends CredentialsExt
     constructor(originalUrlExtractor: TargetExtractor, baseUrl: string);
     canHandle({ headers }: HttpRequest): Promise<void>;
     handle(request: HttpRequest): Promise<Credentials>;
+    private handleBearer;
+    private tokenCredentials;
     private verifyWithLocalRouteFallback;
     private trustedLocalRouteUrl;
     private trustedLocalRouteTransport;

package/dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.js

@@ -12,9 +12,12 @@ const SolidTokenCaches_1 = require("./SolidTokenCaches");
 const SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER = 'x-xpod-canonical-url';
 const SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER = 'x-xpod-local-route-url';
 /**
- * CSS-compatible DPoP credential extractor that admits one configured HTTP
+ * CSS-compatible Solid credential extractor that admits one configured HTTP
  * loopback IP origin without weakening any access-token or DPoP checks.
  *
+ * Both schemes use routed caches so issuer, JWKS and WebID reads can reach
+ * the runtime's socket-only canonical origin.
+ *
  * HTTPS and localhost deployments keep using the upstream verifier unchanged.
  */
 class ConfiguredLoopbackDPoPWebIdExtractor extends community_server_1.CredentialsExtractor {
@@ -40,14 +43,19 @@ class ConfiguredLoopbackDPoPWebIdExtractor extends community_server_1.Credential
     }
     async canHandle({ headers }) {
         const { authorization } = headers;
-        if (typeof authorization !== 'string' || !/^DPoP /iu.test(authorization)) {
-            throw new community_server_1.NotImplementedHttpError('No DPoP-bound Authorization header specified.');
+        if (typeof authorization !== 'string' || !/^(?:DPoP|Bearer) /iu.test(authorization)) {
+            throw new community_server_1.NotImplementedHttpError('No DPoP or Bearer Authorization header specified.');
         }
     }
     async handle(request) {
         const { headers: { authorization, dpop }, method } = request;
         if (typeof authorization !== 'string') {
-            throw new community_server_1.BadRequestHttpError('No DPoP-bound Authorization header specified.');
+            throw new community_server_1.BadRequestHttpError('No DPoP or Bearer Authorization header specified.');
+        }
+        // A Bearer token is not bound to the request URL, so it is verified directly
+        // through the routed caches; no DPoP proof or target URL is consulted.
+        if (/^Bearer /iu.test(authorization)) {
+            return await this.handleBearer(authorization);
         }
         if (typeof dpop !== 'string') {
             throw new community_server_1.BadRequestHttpError('No DPoP header specified.');
@@ -69,11 +77,7 @@ class ConfiguredLoopbackDPoPWebIdExtractor extends community_server_1.Credential
                 url: originalUrl.path,
             });
             this.logger.info(`Verified WebID via DPoP-bound access token. WebID: ${webId}, client ID: ${clientId}, issuer: ${issuer}`);
-            const credentials = { agent: { webId }, issuer: { url: issuer } };
-            if (clientId) {
-                credentials.client = { clientId };
-            }
-            return credentials;
+            return this.tokenCredentials(webId, clientId, issuer);
         }
         catch (error) {
             const reason = error instanceof Error ? error.message : String(error);
@@ -82,6 +86,26 @@ class ConfiguredLoopbackDPoPWebIdExtractor extends community_server_1.Credential
             throw new community_server_1.BadRequestHttpError(message, { cause: error });
         }
     }
+    async handleBearer(authorization) {
+        try {
+            const { webid: webId, client_id: clientId, iss: issuer } = await this.verify(authorization);
+            this.logger.info(`Verified WebID via Bearer access token. WebID: ${webId}, client ID: ${clientId}, issuer: ${issuer}`);
+            return this.tokenCredentials(webId, clientId, issuer);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            const message = `Error verifying WebID via Bearer access token: ${reason}`;
+            this.logger.warn(message);
+            throw new community_server_1.BadRequestHttpError(message, { cause: error });
+        }
+    }
+    tokenCredentials(webId, clientId, issuer) {
+        return {
+            agent: { webId },
+            issuer: { url: issuer },
+            ...(clientId ? { client: { clientId } } : {}),
+        };
+    }
     async verifyWithLocalRouteFallback(request, authorization, dpopOptions) {
         try {
             return await this.verify(authorization, dpopOptions);

package/dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld

@@ -12,7 +12,7 @@
       "extends": [
         "css:dist/authentication/CredentialsExtractor.jsonld#CredentialsExtractor"
       ],
-      "comment": "CSS-compatible DPoP credential extractor that admits one configured HTTP loopback IP origin without weakening any access-token or DPoP checks.  HTTPS and localhost deployments keep using the upstream verifier unchanged.",
+      "comment": "CSS-compatible Solid credential extractor that admits one configured HTTP loopback IP origin without weakening any access-token or DPoP checks.  Both schemes use routed caches so issuer, JWKS and WebID reads can reach the runtime's socket-only canonical origin.  HTTPS and localhost deployments keep using the upstream verifier unchanged.",
       "parameters": [
         {
           "@id": "undefineds:dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld#ConfiguredLoopbackDPoPWebIdExtractor_baseUrl",
@@ -55,6 +55,14 @@
           "@id": "undefineds:dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld#ConfiguredLoopbackDPoPWebIdExtractor__member_handle",
           "memberFieldName": "handle"
         },
+        {
+          "@id": "undefineds:dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld#ConfiguredLoopbackDPoPWebIdExtractor__member_handleBearer",
+          "memberFieldName": "handleBearer"
+        },
+        {
+          "@id": "undefineds:dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld#ConfiguredLoopbackDPoPWebIdExtractor__member_tokenCredentials",
+          "memberFieldName": "tokenCredentials"
+        },
         {
           "@id": "undefineds:dist/authentication/ConfiguredLoopbackDPoPWebIdExtractor.jsonld#ConfiguredLoopbackDPoPWebIdExtractor__member_verifyWithLocalRouteFallback",
           "memberFieldName": "verifyWithLocalRouteFallback"

package/dist/authentication/SolidTokenCaches.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRoutedSolidTokenCaches = createRoutedSolidTokenCaches;
+const node_crypto_1 = require("node:crypto");
 const IssuerKeySetCache_1 = require("@solid/access-token-verifier/dist/class/IssuerKeySetCache");
 const WebIDIssuersCache_1 = require("@solid/access-token-verifier/dist/class/WebIDIssuersCache");
 const jose_1 = require("jose");
@@ -14,6 +15,34 @@ const WEB_ID_DEREFERENCE_RETRY_DELAYS_MS = [0, 200, 500];
 const DEFAULT_CACHE_TTL_MS = 15 * 60 * 1000;
 /** 防止缓存条目无限增长（大量不同 WebID/issuer 的场景）。 */
 const MAX_CACHE_ENTRIES = 1_000;
+// Only fixed transport identifiers may enter the user-visible verifier error.
+// Upstream error messages can contain private URLs, credentials or body text.
+const TRANSPORT_ERROR_CODES = new Set([
+    'BunFetchSocketClosed', 'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EAI_AGAIN', 'ENOTFOUND',
+    'ERR_TLS_CERT_ALTNAME_INVALID', 'CERT_HAS_EXPIRED', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+]);
+const TRANSPORT_ERROR_NAMES = new Set(['Error', 'TypeError', 'AbortError', 'TimeoutError', 'SyntaxError']);
+class TokenDocumentError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'TokenDocumentError';
+    }
+}
+async function observeTokenDocument(stage, phase, logicalUrl, target, operation) {
+    try {
+        return await operation();
+    }
+    catch (cause) {
+        const logicalOrigin = new URL(logicalUrl).origin;
+        const route = new URL(target).origin === logicalOrigin ? 'external' : 'internal';
+        const originHash = (0, node_crypto_1.createHash)('sha256').update(logicalOrigin).digest('hex').slice(0, 16);
+        const code = typeof cause === 'object' && cause !== null && 'code' in cause ? cause.code : undefined;
+        const safeCause = typeof code === 'string' && TRANSPORT_ERROR_CODES.has(code) ? code
+            : cause instanceof Error && TRANSPORT_ERROR_NAMES.has(cause.name) ? cause.name : 'unknown';
+        throw new TokenDocumentError(`Solid token document unavailable (stage=${stage}, phase=${phase}, route=${route}, origin=${originHash}, cause=${safeCause})`, cause);
+    }
+}
 /**
  * A minimal Map-based cache with per-entry TTL and bounded size.
  */
@@ -86,7 +115,8 @@ class FetchWebIdIssuersCache extends WebIDIssuersCache_1.WebIDIssuersCache {
             throw new Error(`WebID dereference failed: HTTP ${response.status}`);
         }
         const baseIRI = response.url || webId;
-        const store = new n3_1.Store(new n3_1.Parser({ baseIRI }).parse(await response.text()));
+        const body = await observeTokenDocument('webid-profile', 'body', webId, this.internalUrl(webId), () => response.text());
+        const store = new n3_1.Store(new n3_1.Parser({ baseIRI }).parse(body));
         const issuers = store
             .getObjects(n3_1.DataFactory.namedNode(webId), SOLID_OIDC_ISSUER, null)
             .map((term) => term.value);
@@ -100,10 +130,10 @@ class FetchWebIdIssuersCache extends WebIDIssuersCache_1.WebIDIssuersCache {
             if (delayMs > 0) {
                 await new Promise((resolve) => setTimeout(resolve, delayMs));
             }
-            response = await fetch(target, {
+            response = await observeTokenDocument('webid-profile', 'headers', webId, target, () => fetch(target, {
                 headers: { Accept: 'text/turtle', ...this.forwardedHeaders(webId) },
                 signal: AbortSignal.timeout(10_000),
-            });
+            }));
             if (response.ok || !this.isTransientBootstrapStatus(response.status)) {
                 return response;
             }
@@ -151,25 +181,29 @@ class FetchIssuerKeySetCache extends IssuerKeySetCache_1.IssuerKeySetCache {
             return cached;
         }
         const logicalConfigurationUrl = new URL('.well-known/openid-configuration', issuer.endsWith('/') ? issuer : `${issuer}/`);
-        const configurationResponse = await fetch(this.internalUrl(logicalConfigurationUrl), {
+        const configurationTarget = this.internalUrl(logicalConfigurationUrl);
+        const configurationResponse = await observeTokenDocument('oidc-discovery', 'headers', logicalConfigurationUrl, configurationTarget, () => fetch(configurationTarget, {
             headers: { Accept: 'application/json', ...this.forwardedHeaders(logicalConfigurationUrl) },
             signal: AbortSignal.timeout(10_000),
-        });
+        }));
         if (!configurationResponse.ok) {
             throw new Error(`OIDC issuer configuration failed: HTTP ${configurationResponse.status}`);
         }
-        const configuration = await configurationResponse.json();
+        const configuration = await observeTokenDocument('oidc-discovery', 'body', logicalConfigurationUrl, configurationTarget, () => configurationResponse.json());
         if (typeof configuration.jwks_uri !== 'string') {
             throw new Error('OIDC issuer configuration is missing jwks_uri');
         }
-        const keySetResponse = await fetch(this.internalUrl(new URL(configuration.jwks_uri)), {
-            headers: { Accept: 'application/json', ...this.forwardedHeaders(configuration.jwks_uri) },
+        const logicalKeySetUrl = new URL(configuration.jwks_uri);
+        const keySetTarget = this.internalUrl(logicalKeySetUrl);
+        const keySetResponse = await observeTokenDocument('issuer-jwks', 'headers', logicalKeySetUrl, keySetTarget, () => fetch(keySetTarget, {
+            headers: { Accept: 'application/json', ...this.forwardedHeaders(logicalKeySetUrl) },
             signal: AbortSignal.timeout(10_000),
-        });
+        }));
         if (!keySetResponse.ok) {
             throw new Error(`OIDC issuer JWKS failed: HTTP ${keySetResponse.status}`);
         }
-        const keySet = (0, jose_1.createLocalJWKSet)(await keySetResponse.json());
+        const keySetBody = await observeTokenDocument('issuer-jwks', 'body', logicalKeySetUrl, keySetTarget, () => keySetResponse.json());
+        const keySet = (0, jose_1.createLocalJWKSet)(keySetBody);
         this.resolved.set(issuer, keySet);
         return keySet;
     }

package/dist/cli/agent-fs/args.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Conservative ripgrep argv classifier.
+ *
+ * Only argument combinations whose semantics the HTTP search backend can
+ * reproduce exactly are taken over. Everything else (regex patterns, stdin,
+ * ignore-file handling, context flags, unsupported output modes) is reported as
+ * `fallback` so the caller can exec the pre-resolved native binary unchanged.
+ */
+export type RgFallbackReason = string;
+export interface RgFilesInvocation {
+    kind: 'files';
+    hidden: boolean;
+    sort: 'path';
+    pathArg?: string;
+}
+export interface RgSearchInvocation {
+    kind: 'search';
+    query: string;
+    hidden: boolean;
+    sort: 'path';
+    ignoreCase: boolean;
+    lineNumber?: boolean;
+    filesWithMatches: boolean;
+    count: boolean;
+    noHeading: boolean;
+    color: 'never' | 'auto';
+    pathArg?: string;
+}
+export type RgInvocation = RgFilesInvocation | RgSearchInvocation;
+export type RgParseResult = {
+    kind: 'managed';
+    invocation: RgInvocation;
+} | {
+    kind: 'fallback';
+    reason: RgFallbackReason;
+};
+export declare function parseRgArgs(argv: string[]): RgParseResult;