@xopcai/xopc 0.0.312 → 0.0.314

package/dist/src/mcp/gateway-http-client.js

@@ -1,13 +1,29 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { CapabilityErrorCodeSchema } from "../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { init_loader, loadConfig } from "../config/loader.js";
 import { resolveGatewayLocalClientHost } from "../config/gateway-bind.js";
 import { createGatewayCredential, gatewayCredentialAuthorization } from "../gateway/credential.js";
 import { fetch } from "undici";
 //#region src/mcp/gateway-http-client.ts
+init_src();
 init_loader();
 init_logger();
 const log = createLogger("Mcp:GatewayClient");
+var GatewayHttpError = class extends Error {
+	constructor(status, code, operationId) {
+		super(`Gateway request failed (${status})`);
+		this.status = status;
+		this.code = code;
+		this.operationId = operationId;
+	}
+};
+async function responseError(res) {
+	const body = await res.json().catch(() => null);
+	const code = CapabilityErrorCodeSchema.safeParse(body?.code);
+	return new GatewayHttpError(res.status, code.success ? code.data : void 0, typeof body?.operationId === "string" && body.operationId.length <= 200 ? body.operationId : void 0);
+}
 function resolveGatewayCredentialFromConfig(cfg) {
 	const auth = cfg.gateway?.auth;
 	if (auth?.mode === "password") return createGatewayCredential("password", auth.password);
@@ -27,7 +43,11 @@ var GatewayHttpClient = class {
 		return h;
 	}
 	async getJson(path) {
-		const res = await fetch(`${this.opts.baseUrl}${path}`, { headers: this.headers() });
+		const res = await fetch(`${this.opts.baseUrl}${path}`, {
+			headers: this.headers(),
+			redirect: "error",
+			signal: AbortSignal.timeout(3e4)
+		});
 		if (!res.ok) {
 			const em = `Gateway GET ${path} failed: ${res.status}`;
 			log.warn({
@@ -36,7 +56,7 @@ var GatewayHttpClient = class {
 				path,
 				status: res.status
 			}, em);
-			throw new Error(em);
+			throw await responseError(res);
 		}
 		const body = await res.json();
 		if (body && typeof body === "object" && "payload" in body) return body.payload;
@@ -46,7 +66,9 @@ var GatewayHttpClient = class {
 		const res = await fetch(`${this.opts.baseUrl}${path}`, {
 			method: "POST",
 			headers: this.headers({ "Content-Type": "application/json" }),
-			body: JSON.stringify(data)
+			body: JSON.stringify(data),
+			redirect: "error",
+			signal: AbortSignal.timeout(3e4)
 		});
 		if (!res.ok) {
 			const em = `Gateway POST ${path} failed: ${res.status}`;
@@ -56,7 +78,7 @@ var GatewayHttpClient = class {
 				path,
 				status: res.status
 			}, em);
-			throw new Error(em);
+			throw await responseError(res);
 		}
 		const body = await res.json();
 		if (body && typeof body === "object" && "payload" in body) return body.payload;
@@ -76,4 +98,4 @@ function createGatewayHttpClientFromConfig(params) {
 	});
 }
 //#endregion
-export { GatewayHttpClient, createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl };
+export { GatewayHttpClient, GatewayHttpError, createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl };

package/dist/src/media-understanding/openai-compatible-audio.js

@@ -1,6 +1,6 @@
+import { registerMediaUnderstandingProvider } from "./registry.js";
 import { normalizeBaseUrl, postMultipartRequest } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
-import { registerMediaUnderstandingProvider } from "./registry.js";
 import path from "node:path";
 //#region src/media-understanding/openai-compatible-audio.ts
 /**

package/dist/src/notes/agent-context.js

@@ -2,11 +2,11 @@ import { getNoteAgentContextRecord, upsertNoteAgentContextRecord } from "../stor
 import "../storage/sqlite/index.js";
 import { resolveImageModelConfigForTool } from "../agent/image/tool-model-config.js";
 import { describeImagesWithFallback } from "../agent/image/understanding/runtime.js";
+import { extractDocumentText } from "../document-understanding/extract.js";
 import { transcribe } from "../voice/stt/transcribe-core.js";
 import { isSTTAvailable } from "../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
-import { extractDocumentText } from "../document-understanding/extract.js";
 import { extname } from "node:path";
 import { readFile } from "node:fs/promises";
 //#region src/notes/agent-context.ts

package/dist/src/notes/capabilities/read.d.ts

@@ -0,0 +1,3 @@
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import type { NotesService } from '../service.js';
+export declare function registerNoteReadCapabilities(dispatcher: CapabilityDispatcher, getNotes: () => Pick<NotesService, 'getNote' | 'listNotes' | 'listProjectSummaries' | 'listNoteHistory' | 'getNoteSnapshot' | 'createAiEditPatch'>): void;

package/dist/src/notes/capabilities/read.js

@@ -0,0 +1,96 @@
+import { ProductReadContracts } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+//#region src/notes/capabilities/read.ts
+init_src();
+function registerNoteReadCapabilities(dispatcher, getNotes) {
+	const policy = {
+		majorVersion: 1,
+		effect: "read",
+		surfaces: [
+			"http",
+			"agent",
+			"cli"
+		],
+		scopes: ["workspace.read"]
+	};
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.notes.preview_edit",
+		description: "Build a local edit suggestion without modifying the note or calling a model.",
+		...ProductReadContracts["xopc.notes.preview_edit"],
+		async execute({ id, instruction, markdown }) {
+			const result = await getNotes().createAiEditPatch(id, instruction, markdown);
+			if (!result) throw new CapabilityError("NOT_FOUND", "Note not found");
+			return ProductReadContracts["xopc.notes.preview_edit"].output.parse(result);
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.notes.project_summaries",
+		description: "List project note counts without rebuilding understanding.",
+		...ProductReadContracts["xopc.notes.project_summaries"],
+		execute: () => ({ items: getNotes().listProjectSummaries() })
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.notes.history",
+		description: "List immutable note history snapshots.",
+		...ProductReadContracts["xopc.notes.history"],
+		execute: async ({ id }) => ({ entries: await getNotes().listNoteHistory(id) })
+	}));
+	dispatcher.register(defineReadCapability({
+		...policy,
+		id: "xopc.notes.snapshot",
+		description: "Read one note snapshot at an exact timestamp.",
+		...ProductReadContracts["xopc.notes.snapshot"],
+		async execute({ id, timestamp }) {
+			const snapshot = await getNotes().getNoteSnapshot(id, timestamp);
+			if (!snapshot) throw new CapabilityError("NOT_FOUND", "Snapshot not found");
+			return { snapshot };
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		id: "xopc.notes.get",
+		majorVersion: 1,
+		description: "Read a note by its stable ID.",
+		effect: "read",
+		surfaces: [
+			"http",
+			"agent",
+			"cli",
+			"extension"
+		],
+		scopes: ["workspace.read"],
+		...ProductReadContracts["xopc.notes.get"],
+		async execute({ id }) {
+			const note = await getNotes().getNote(id);
+			if (!note) throw new CapabilityError("NOT_FOUND", `Note not found: ${id}`);
+			return { note: { ...note } };
+		}
+	}));
+	dispatcher.register(defineReadCapability({
+		id: "xopc.notes.list",
+		majorVersion: 1,
+		description: "List notes using explicit filters and pagination.",
+		effect: "read",
+		surfaces: [
+			"http",
+			"agent",
+			"cli",
+			"extension"
+		],
+		scopes: ["workspace.read"],
+		...ProductReadContracts["xopc.notes.list"],
+		async execute(input) {
+			const result = await getNotes().listNotes(input);
+			return {
+				...result,
+				items: result.items.map((item) => ({ ...item }))
+			};
+		}
+	}));
+}
+//#endregion
+export { registerNoteReadCapabilities };

package/dist/src/notes/capabilities/write.d.ts

@@ -0,0 +1,7 @@
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import { type NotesService } from '../service.js';
+import type { ProjectService } from '../../projects/index.js';
+export declare function registerNoteWriteCapabilities(dispatcher: CapabilityDispatcher, deps: {
+    getNotes: () => NotesService;
+    getProjects?: () => ProjectService | undefined;
+}): void;

package/dist/src/notes/capabilities/write.js

@@ -0,0 +1,152 @@
+import { NoteAppendInputSchema, NoteCaptureInputSchema, NoteCreateInputSchema, NoteDeleteInputSchema, NoteDeleteOutputSchema, NoteGetOutputSchema, NoteRestoreInputSchema, NoteUpdateInputSchema } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { ObjectLinkService } from "../../activity/service.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
+import { NoteRevisionConflictError } from "../service.js";
+//#region src/notes/capabilities/write.ts
+init_src();
+function registerNoteWriteCapabilities(dispatcher, deps) {
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.delete",
+		majorVersion: 1,
+		description: "Delete a note at an exact revision, revoke shares by default, and durably queue file cleanup after commit.",
+		effect: "local-write",
+		surfaces: ["http", "agent"],
+		scopes: ["workspace.write"],
+		input: NoteDeleteInputSchema,
+		output: NoteDeleteOutputSchema,
+		execute({ id, expectedRevision, revokeShares }) {
+			try {
+				const result = deps.getNotes().deleteNoteAtomically(id, expectedRevision, revokeShares);
+				if (!result.deleted) throw new CapabilityError("NOT_FOUND", "Note not found");
+				return {
+					deleted: true,
+					revokedShares: result.revokedShares
+				};
+			} catch (error) {
+				if (error instanceof NoteRevisionConflictError) throw new CapabilityError("REVISION_CONFLICT", error.message);
+				throw error;
+			}
+		},
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+	const result = (execute) => {
+		try {
+			const note = execute();
+			if (!note) throw new CapabilityError("NOT_FOUND", "Note or snapshot not found");
+			return { note: { ...note } };
+		} catch (error) {
+			if (error instanceof NoteRevisionConflictError) throw new CapabilityError("REVISION_CONFLICT", error.message);
+			throw error;
+		}
+	};
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.capture",
+		majorVersion: 1,
+		description: "Capture text with a durable receipt.",
+		effect: "local-write",
+		surfaces: ["http"],
+		scopes: ["workspace.write"],
+		input: NoteCaptureInputSchema,
+		output: NoteGetOutputSchema,
+		execute: (input, context) => result(() => deps.getNotes().quickCaptureAtomically(input.text, input.capturedVia, context.idempotencyKey)),
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.append",
+		majorVersion: 1,
+		description: "Append text once without replacing concurrent content.",
+		effect: "local-write",
+		surfaces: [
+			"http",
+			"agent",
+			"extension"
+		],
+		scopes: ["workspace.write"],
+		input: NoteAppendInputSchema,
+		output: NoteGetOutputSchema,
+		execute: (input) => result(() => deps.getNotes().appendTextToNoteAtomically(input.id, input.content, input.heading, input.expectedRevision)),
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.restore",
+		majorVersion: 1,
+		description: "Restore a snapshot at an exact current note revision.",
+		effect: "local-write",
+		surfaces: ["http"],
+		scopes: ["workspace.write"],
+		input: NoteRestoreInputSchema,
+		output: NoteGetOutputSchema,
+		execute: (input) => result(() => deps.getNotes().restoreNoteSnapshotAtomically(input.id, input.timestamp, input.expectedRevision)),
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.create",
+		majorVersion: 1,
+		description: "Create a note with a durable receipt and optional project link.",
+		effect: "local-write",
+		surfaces: [
+			"http",
+			"agent",
+			"extension"
+		],
+		scopes: ["workspace.write"],
+		input: NoteCreateInputSchema,
+		output: NoteGetOutputSchema,
+		execute({ projectId, ...input }, context) {
+			const project = projectId ? deps.getProjects?.()?.get(projectId) : void 0;
+			if (projectId && !project) throw new CapabilityError("NOT_FOUND", "Project not found");
+			const note = deps.getNotes().createNoteAtomically(input, context.idempotencyKey);
+			if (project) new ObjectLinkService().create({
+				id: `note:${note.id}:project:${project.id}`,
+				from: {
+					kind: "note",
+					id: note.id,
+					title: note.title
+				},
+				to: {
+					kind: "project",
+					id: project.id,
+					title: project.name
+				},
+				relation: "belongs_to",
+				source: "user"
+			});
+			return { note: { ...note } };
+		},
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.notes.update",
+		majorVersion: 1,
+		description: "Update a note at an exact revision; file cleanup is durable and post-commit.",
+		effect: "local-write",
+		surfaces: [
+			"http",
+			"agent",
+			"extension"
+		],
+		scopes: ["workspace.write"],
+		input: NoteUpdateInputSchema,
+		output: NoteGetOutputSchema,
+		execute(input, context) {
+			return result(() => deps.getNotes().updateNoteAtomically(input.id, input.patch, context.surface === "agent" ? "ai_edit" : input.trigger ?? "edit", input.expectedRevision));
+		},
+		afterCommit() {
+			deps.getNotes().flushCommittedEffects();
+		}
+	}));
+}
+//#endregion
+export { registerNoteWriteCapabilities };

package/dist/src/notes/index.js

@@ -1,5 +1,5 @@
+import { buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
 import { resolveNoteMediaDir, resolveNotesDir } from "./paths.js";
 import { NotesStore } from "./store.js";
-import { buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
 import { NotesService } from "./service.js";
 export { NotesService, NotesStore, buildNoteAgentContext, buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact, resolveNoteMediaDir, resolveNotesDir };

package/dist/src/notes/service.d.ts

@@ -2,20 +2,22 @@ import type { Config } from '../config/schema.js';
 import { buildNoteAttachmentRef } from './attachment-ref.js';
 import { NotesStore } from './store.js';
 import type { CaptureSource, CreateNoteParams, Note, NoteAiPatch, NoteAttachment, NoteCatalysisReport, NoteIndexEntry, NoteSnapshot, NoteSnapshotEntry, NotesListQuery, SnapshotTrigger } from './types.js';
+export declare class NoteRevisionConflictError extends Error {
+}
 export declare class NotesService {
     private readonly store;
-    private lastSnapshotAt;
-    private quickCapturesInFlight;
-    private noteCapturesInFlight;
     private noteAttachmentsInFlight;
     constructor(store?: NotesStore);
     initialize(): Promise<void>;
+    flushCommittedEffects(): void;
     quickCapture(markdown: string, source: CaptureSource, idempotencyKey?: string): Promise<Note>;
-    private createQuickCapture;
+    quickCaptureAtomically(markdown: string, source: CaptureSource, idempotencyKey?: string): Note;
     createNote(params: CreateNoteParams, idempotencyKey?: string): Promise<Note>;
+    createNoteAtomically(params: CreateNoteParams, idempotencyKey?: string): Note;
     private createNoteWithId;
     getNote(id: string): Promise<Note | null>;
     updateNote(id: string, patch: Partial<Note>, trigger?: SnapshotTrigger): Promise<Note | null>;
+    updateNoteAtomically(id: string, patch: Partial<Note>, trigger?: SnapshotTrigger, expectedRevision?: number): Note | null;
     private reconcileAttachments;
     syncNote(id: string, patch: Partial<Note>, baseRemoteVersion?: number): Promise<{
         note: Note | null;
@@ -38,7 +40,12 @@ export declare class NotesService {
         stale: boolean;
     } | null>;
     appendTextToNote(id: string, content: string, heading?: string): Promise<Note | null>;
+    appendTextToNoteAtomically(id: string, content: string, heading?: string, expectedRevision?: number): Note | null;
     deleteNote(id: string): Promise<boolean>;
+    deleteNoteAtomically(id: string, expectedRevision?: number, revokeShares?: boolean): {
+        deleted: boolean;
+        revokedShares: number;
+    };
     listNotes(query?: NotesListQuery): Promise<{
         items: NoteIndexEntry[];
         total: number;
@@ -66,6 +73,7 @@ export declare class NotesService {
     listNoteHistory(noteId: string): Promise<NoteSnapshotEntry[]>;
     getNoteSnapshot(noteId: string, timestamp: number): Promise<NoteSnapshot | null>;
     restoreNoteSnapshot(noteId: string, timestamp: number): Promise<Note | null>;
+    restoreNoteSnapshotAtomically(noteId: string, timestamp: number, expectedRevision?: number): Note | null;
     moveToGroup(noteId: string, groupId: string | null): Promise<Note | null>;
     createTask(title: string, source: CaptureSource, opts?: {
         dueAt?: number;