@conduction/nextcloud-vue 2.119.0 → 2.120.0

package/src/components/CnTimelineWidget/CnTimelineWidget.vue

@@ -1,7 +1,16 @@
 <!-- SPDX-License-Identifier: EUPL-1.2 -->
 <!-- SPDX-FileCopyrightText: 2026 Conduction B.V. <info@conduction.nl> -->
 <template>
-	<section class="cn-timeline-widget" data-testid="cn-timeline-widget" :aria-busy="loading ? 'true' : 'false'">
+	<CnTimelineManage v-if="manage"
+		:register="resolvedRegister"
+		:schema="resolvedSchema"
+		:objectId="resolvedObjectId"
+		:apiBase="apiBase"
+		:content="content" />
+	<section v-else
+		class="cn-timeline-widget"
+		data-testid="cn-timeline-widget"
+		:aria-busy="loading ? 'true' : 'false'">
 		<h3 v-if="resolvedTitle" class="cn-timeline-widget__title">
 			{{ resolvedTitle }}
 		</h3>
@@ -53,6 +62,7 @@
 <script>
 import { getLanguage, translate as t } from '@nextcloud/l10n'
 import { NcLoadingIcon, NcNoteCard } from '@nextcloud/vue'
+import CnTimelineManage from './CnTimelineManage.vue'
 import { auditEvents, fieldEvents, listEvents, relatedEvents, sortEvents, timelineEntryEvents } from '../../utils/timelineEvents.js'
 import { userLocale } from '../../utils/userLocale.js'
 
@@ -74,6 +84,12 @@ import { userLocale } from '../../utils/userLocale.js'
  * Oldest first by default (`order: 'desc'` flips it). A moment after now is
  * marked upcoming, in words as well as style.
  *
+ * `manage: true` swaps the read view for the manage view (CnTimelineManage)
+ * over OpenRegister's timeline alone: kind chips, a visibility filter, pin,
+ * follow-up, a note composer with standard text blocks, CSV export, and
+ * `entryActions` that open a registry modal on an entry. The manage controls
+ * are drawn only when the timeline read answers `canManage: true`.
+ *
  * ```json
  * { "type": "timeline", "content": {
  *   "title": "Timeline",
@@ -95,6 +111,7 @@ export default {
 	name: 'CnTimelineWidget',
 
 	components: {
+		CnTimelineManage,
 		NcLoadingIcon,
 		NcNoteCard,
 	},
@@ -123,7 +140,7 @@ export default {
 		object: { type: Object, default: null },
 		/** Card title override. */
 		title: { type: String, default: '' },
-		/** Stored widget content: `{ title, fields, related, auditTrail, timeline, order }`. */
+		/** Stored widget content: `{ title, fields, related, auditTrail, timeline, order, manage, entryActions, ... }`. */
 		content: { type: Object, default: () => ({}) },
 		/** OpenRegister API base. */
 		apiBase: { type: String, default: '/apps/openregister/api' },
@@ -172,6 +189,15 @@ export default {
 			return this.object || this.ctx.object || this.ctx.objectData || this.fetchedObject || null
 		},
 
+		/**
+		 * Whether the manage view renders instead of the read view.
+		 *
+		 * @return {boolean}
+		 */
+		manage() {
+			return this.content.manage === true
+		},
+
 		resolvedTitle() {
 			const raw = this.title || this.content.title || ''
 			return raw ? this.translate(raw) : ''
@@ -313,7 +339,7 @@ export default {
 			const register = this.resolvedRegister
 			const schema = this.resolvedSchema
 			const seq = ++this.loadSeq
-			if (!id || !register || !schema) {
+			if (!id || !register || !schema || this.manage) {
 				return
 			}
 			const [{ default: axios }, { generateUrl }] = await Promise.all([

package/src/components/CnWidgetGrid/builtInWidgets.js

@@ -26,6 +26,7 @@ import CnNoticeWidget from '../CnNoticeWidget/CnNoticeWidget.vue'
 import CnObjectDataWidget from '../CnObjectDataWidget/CnObjectDataWidget.vue'
 import CnObjectGeoWidget from '../CnObjectGeoWidget/CnObjectGeoWidget.vue'
 import CnObjectMetadataWidget from '../CnObjectMetadataWidget/CnObjectMetadataWidget.vue'
+import CnObjectTranslationsWidget from '../CnObjectTranslationsWidget/CnObjectTranslationsWidget.vue'
 import CnRelatedObjectsWidget from '../CnRelatedObjectsWidget/CnRelatedObjectsWidget.vue'
 import CnSavedViewAlertWidget from '../CnSavedViewAlertWidget/CnSavedViewAlertWidget.vue'
 import CnTextWidget from '../CnTextWidget/CnTextWidget.vue'
@@ -74,6 +75,10 @@ import CnWidgetObjectTable from '../CnWidgetObjectTable/CnWidgetObjectTable.vue'
  * data — the intended remedy for a deep menu group collapsed into one
  * top-level entry via `menu-layout.json` relocations.
  *
+ * The `object-translations` key places CnObjectTranslationsWidget: the
+ * object's translatable properties per register language, with completeness
+ * chips and one save (register / schema / objectId via the detail-context merge).
+ *
  * @type {Record<string, import('vue').Component>}
  */
 export const BUILT_IN_WIDGETS = {
@@ -97,4 +102,5 @@ export const BUILT_IN_WIDGETS = {
 	divider: CnDividerWidget,
 	'saved-view-alert': CnSavedViewAlertWidget,
 	exports: CnExportsWidget,
+	'object-translations': CnObjectTranslationsWidget,
 }

package/src/components/index.js

@@ -77,6 +77,7 @@ export { CnRegisterSchemaSelect } from './CnRegisterSchemaSelect/index.js'
 export { CnThemePreview } from './CnThemePreview/index.js'
 export { CnRelationshipGraph } from './CnRelationshipGraph/index.js'
 export { CnGraphCanvas } from './CnGraphCanvas/index.js'
+export { CnStateMachineEditor } from './CnStateMachineEditor/index.js'
 export { CnFlowDetail, CnFlowIndexPage, CnFlowSidebar } from './CnFlowDetail/index.js'
 export { CnIcon, ICON_MAP, registerIcons } from './CnIcon/index.js'
 export {
@@ -167,7 +168,10 @@ export { CnJourneyDialog } from './CnJourneyDialog/index.js'
 export { CnProcessSteps } from './CnProcessSteps/index.js'
 export { CnSubObjectsField } from './CnSubObjectsField/index.js'
 export { CnIntegrationTab } from './CnIntegrationTab/index.js'
+export { CnAiFeaturesWidget } from './CnAiFeaturesWidget/index.js'
 export { CnObjectAccessTab } from './CnObjectAccessTab/index.js'
+export { CnObjectPermissionsTab } from './CnObjectPermissionsTab/index.js'
+export { CnObjectTranslationsWidget } from './CnObjectTranslationsWidget/index.js'
 export { CnIntegrationCard } from './CnIntegrationCard/index.js'
 export { CnIntegrationWidgetGrid } from './CnIntegrationWidgetGrid/index.js'
 export { CnIntegrationWidget } from './CnIntegrationWidget/index.js'

package/src/index.js

@@ -40,6 +40,7 @@ export {
 	CnAdminActionCard,
 	CnAdminSettingsShell,
 	CnAdvancedFormDialog,
+	CnAiFeaturesWidget,
 	CnApiReference,
 	CnAppLoading,
 	CnAppNav,
@@ -249,9 +250,11 @@ export {
 	CnObjectMetadataModal,
 	CnObjectMetadataWidget,
 	CnObjectPartiesWidget,
+	CnObjectPermissionsTab,
 	CnObjectPresenceWidget,
 	CnObjectRow,
 	CnObjectSidebar,
+	CnObjectTranslationsWidget,
 	CnOfflineQueue,
 	CnOrderedListField,
 	CnPageHeader,
@@ -317,6 +320,7 @@ export {
 	CnSpendAnalyticsWidgetForm,
 	CnStagesWidget,
 	CnStagesWidgetForm,
+	CnStateMachineEditor,
 	CnStatsBlock,
 	CnStatsBlockWidget,
 	CnStatsBlockWidgetForm,
@@ -618,6 +622,7 @@ export { DYNAMIC_KEY_PREFIX, EXTENDS_FORM_KEY, PREFILL_KEY, splitDynamicFormData
 // drift on what a 409 means (breaking change / schema still has objects).
 export { deleteSchema, describeSchemaChange, saveSchema, SchemaBreakingChangeError, SchemaHasObjectsError } from './utils/index.js'
 export { validateManifest, validateManifestV2 } from './utils/validateManifest.js'
+export { validateStateMachine } from './utils/stateMachineValidation.js'
 export { clearResolveCache, resolveManifestSentinels } from './utils/resolveManifestSentinels.js'
 export { clearRouteSentinelWarnings, resolveRouteSentinels } from './utils/resolveRouteSentinels.js'
 export {

package/src/utils/aiFeatures.js

@@ -0,0 +1,241 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * The reads and the run behind CnAiFeaturesWidget: the AI features a record's
+ * TYPE object places on a surface, where hermiq runs each one, a run on one of
+ * the record's documents, and the sentence a refusal is shown as.
+ *
+ * An undeclared type asks nobody: the declaration is read first and the
+ * features endpoint is called only when something is placed on the surface.
+ * Every read answers null when it failed, so the widget can say it is
+ * incomplete instead of drawing an empty list.
+ *
+ * The run goes to hermiq in the reader's own session, so their own access
+ * decides which document can be read. A request without a usable document
+ * reference is refused before it is sent: hermiq's redaction gate sits on the
+ * document, and a request without one would run unchecked.
+ */
+import axios from '@nextcloud/axios'
+import { translate as t } from '@nextcloud/l10n'
+import { prefixUrl } from './headers.js'
+
+/** The gate name for a run refused before it was sent. */
+export const MISSING_REFERENCE = 'missing-reference'
+
+/** The hermiq endpoint a feature runs on a document through; `{slug}` is filled in. */
+export const DEFAULT_RUN_ENDPOINT = '/apps/hermiq/api/ai-features/{slug}/run-on-document'
+
+/**
+ * A run that was refused, before sending or by one of hermiq's gates.
+ */
+export class AiFeatureRefusal extends Error {
+	/**
+	 * @param {string}      feature The feature slug.
+	 * @param {string}      reason  The refusing side's own sentence.
+	 * @param {string|null} gate    The gate that refused, when named.
+	 */
+	constructor(feature, reason, gate) {
+		super(reason)
+		this.name = 'AiFeatureRefusal'
+		this.feature = feature
+		this.reason = reason
+		this.gate = gate
+	}
+}
+
+/**
+ * The id inside a reference that may be a plain id or an object carrying one.
+ *
+ * @param {string|object|null|undefined} value The reference.
+ * @return {string} The id, or ''.
+ */
+export function referenceId(value) {
+	if (value !== null && typeof value === 'object') {
+		return String(value.id ?? value.uuid ?? '').trim()
+	}
+	return String(value ?? '').trim()
+}
+
+/**
+ * The slugs a type object places on one surface. The declaration is a map of
+ * feature slug to surface name.
+ *
+ * @param {object} typeObject The type object.
+ * @param {string} field      The declaration field.
+ * @param {string} surface    The surface.
+ * @return {Array<string>} The slugs, in declaration order.
+ */
+export function surfaceSlugs(typeObject, field, surface) {
+	const declared = typeObject?.[field]
+	if (declared === null || typeof declared !== 'object' || Array.isArray(declared)) {
+		return []
+	}
+	return Object.keys(declared).filter((slug) => declared[slug] === surface)
+}
+
+/**
+ * Read one OpenRegister object.
+ *
+ * @param {string} apiBase  API root.
+ * @param {string} register Register.
+ * @param {string} schema   Schema.
+ * @param {string} id       Object id.
+ * @return {Promise<object>} The object.
+ */
+async function readObject(apiBase, register, schema, id) {
+	const { data } = await axios.get(prefixUrl(`${apiBase}/objects/${register}/${schema}/${encodeURIComponent(id)}`))
+	return data?.object ?? data ?? {}
+}
+
+/**
+ * The AI features the record's type places on the surface, each with where it
+ * runs as the features endpoint answers it.
+ *
+ * @param {object} options                         The options.
+ * @param {string} options.apiBase                 OpenRegister API root.
+ * @param {string} options.register                Register.
+ * @param {string} options.schema                  Schema of the record.
+ * @param {string} options.objectId                The record id.
+ * @param {object} options.declaration             `{typeField, typeSchema, field, surface}`.
+ * @param {string} options.featuresEndpoint        The endpoint that asks hermiq.
+ * @param {string} options.featuresQueryKey        Query key the slugs are sent under.
+ * @return {Promise<Array<object>|null>} The features, or null when they could not be read.
+ */
+export async function fetchFeatures({ apiBase, register, schema, objectId, declaration, featuresEndpoint, featuresQueryKey }) {
+	try {
+		const record = await readObject(apiBase, register, schema, objectId)
+		const typeId = referenceId(record[declaration.typeField])
+		if (typeId === '') {
+			return []
+		}
+		const typeObject = await readObject(apiBase, register, declaration.typeSchema, typeId)
+		const slugs = surfaceSlugs(typeObject, declaration.field || 'aiFeatures', declaration.surface)
+		if (slugs.length === 0) {
+			return []
+		}
+
+		const query = new URLSearchParams({ surface: declaration.surface })
+		for (const slug of slugs) {
+			query.append(`${featuresQueryKey}[${slug}]`, declaration.surface)
+		}
+		const { data } = await axios.get(`${prefixUrl(featuresEndpoint)}?${query.toString()}`)
+		return Array.isArray(data?.features) ? data.features : []
+	} catch {
+		return null
+	}
+}
+
+/**
+ * The record's documents a feature can be run on.
+ *
+ * @param {string} url The files endpoint.
+ * @return {Promise<Array<{id: string, title: string}>|null>} The documents, or null.
+ */
+export async function fetchDocuments(url) {
+	try {
+		const { data } = await axios.get(prefixUrl(url))
+		const rows = Array.isArray(data?.results) ? data.results : (Array.isArray(data) ? data : [])
+		return rows
+			.filter((row) => row && row.id !== undefined && row.id !== null)
+			.map((row) => ({ id: String(row.id), title: String(row.title ?? row.name ?? row.id) }))
+	} catch {
+		return null
+	}
+}
+
+/**
+ * The prompts offered on the record, as the endpoint holds them.
+ *
+ * @param {string} url The prompts endpoint.
+ * @return {Promise<Array<{id: string, label: string, prompt: string}>|null>} The prompts, or null.
+ */
+export async function fetchPrompts(url) {
+	try {
+		const { data } = await axios.get(prefixUrl(url))
+		return Array.isArray(data?.prompts) ? data.prompts : []
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Ask one prompt about the record.
+ *
+ * @param {string} url       The ask endpoint.
+ * @param {string} objectKey Body key naming the record.
+ * @param {string} objectId  The record id.
+ * @param {string} message   The prompt.
+ * @return {Promise<object>} `{reply, model?}`.
+ */
+export async function askAbout(url, objectKey, objectId, message) {
+	const { data } = await axios.post(prefixUrl(url), { [objectKey]: objectId, message })
+	return data
+}
+
+/**
+ * Where a feature runs, in words. A feature hermiq does not offer reads
+ * unavailable, never local.
+ *
+ * @param {object} feature One feature row.
+ * @return {string} The sentence.
+ */
+export function whereItRuns(feature) {
+	if (feature?.available !== true) {
+		return t('nextcloud-vue', 'Unavailable: hermiq does not offer this feature here.')
+	}
+	const provider = String(feature.provider ?? '').trim()
+	const residency = String(feature.residency ?? '').trim()
+	if (provider === '' || residency === '') {
+		return t('nextcloud-vue', 'hermiq did not say which provider runs this, or where.')
+	}
+	return t('nextcloud-vue', '{provider}, runs in {residency}', { provider, residency })
+}
+
+/**
+ * Run one AI feature on one document, through hermiq.
+ *
+ * @param {object}        request                   The run.
+ * @param {string}        request.feature           The feature slug.
+ * @param {string|number} request.documentReference The document's file id.
+ * @param {string}        request.instruction       What to do with it.
+ * @param {string}        [request.runEndpoint]     Endpoint template with `{slug}`.
+ * @return {Promise<object>} hermiq's answer.
+ * @throws {AiFeatureRefusal} When the reference is missing, or hermiq refuses.
+ */
+export async function runFeatureOnDocument({ feature, documentReference, instruction, runEndpoint = DEFAULT_RUN_ENDPOINT }) {
+	const reference = String(documentReference ?? '').trim()
+	if (/^\d+$/.test(reference) === false) {
+		throw new AiFeatureRefusal(feature, t('nextcloud-vue', 'No document was chosen.'), MISSING_REFERENCE)
+	}
+
+	const url = prefixUrl(runEndpoint.replace('{slug}', encodeURIComponent(feature)))
+	try {
+		const response = await axios.post(url, { documentReference: reference, instruction })
+		return response.data
+	} catch (error) {
+		const status = error?.response?.status
+		const data = error?.response?.data ?? {}
+		if ([400, 403, 404, 422].includes(status) === true) {
+			throw new AiFeatureRefusal(feature, String(data.error ?? ''), data.gate ?? null)
+		}
+		throw error
+	}
+}
+
+/**
+ * The sentence a reader sees for a refusal, naming the feature and the reason.
+ *
+ * @param {AiFeatureRefusal} refusal      The refusal.
+ * @param {string}           featureLabel The feature's name.
+ * @return {string} The sentence.
+ */
+export function refusalSentence(refusal, featureLabel) {
+	if (refusal.gate === MISSING_REFERENCE) {
+		return t('nextcloud-vue', '{feature} reads a document, and no document was chosen.', { feature: featureLabel })
+	}
+	if (refusal.gate === 'redaction') {
+		return t('nextcloud-vue', '{feature} will not read a document that has not been redacted.', { feature: featureLabel })
+	}
+	return t('nextcloud-vue', '{feature} did not run: {reason}', { feature: featureLabel, reason: refusal.reason })
+}

package/src/utils/aiSuggestionTracker.js

@@ -0,0 +1,178 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ *
+ * Reports what a person did with each AI suggestion on a record, for the AI
+ * oversight trail (EU AI Act art. 14). Every suggestion that is shown ends in
+ * exactly one report: accepted, modified or rejected when the person acts on
+ * it, and ignored when they do not. An ignored suggestion says why: a newer
+ * suggestion replaced it (superseded), its surface was closed (closed), or it
+ * stayed open past its lifetime (expired).
+ *
+ * The app's record-action endpoint writes the local audit entry and hands the
+ * decision to hermiq; without hermiq it keeps only the local entry.
+ */
+import { getRequestToken } from '@nextcloud/auth'
+import axios from '@nextcloud/axios'
+import { prefixUrl } from './headers.js'
+
+/** How long a shown suggestion waits for a decision before it expires. */
+export const SUGGESTION_LIFETIME_MS = 30 * 60 * 1000
+
+/**
+ * Post one decision to the record-action endpoint.
+ *
+ * @param {string} endpoint The record-action endpoint.
+ * @param {object} body The record-action body.
+ * @param {object} options Options.
+ * @param {boolean} options.leaving True while the page unloads: the request
+ *   then uses `fetch` with `keepalive`, which outlives the page.
+ * @return {Promise<void>}
+ */
+export async function postDecision(endpoint, body, { leaving = false } = {}) {
+	const url = prefixUrl(endpoint)
+	if (leaving === true) {
+		await fetch(url, {
+			method: 'POST',
+			keepalive: true,
+			headers: {
+				'Content-Type': 'application/json',
+				requesttoken: getRequestToken() ?? '',
+			},
+			body: JSON.stringify(body),
+		})
+		return
+	}
+
+	await axios.post(url, body)
+}
+
+/**
+ * Track the suggestions shown on one record.
+ *
+ * A suggestion is shown under a slot key (one feature, or the questions); a
+ * newer suggestion in the same slot supersedes an undecided older one.
+ *
+ * @param {object} options Options.
+ * @param {string} options.objectId The record id.
+ * @param {string} [options.objectKey] Body key naming the record (default `objectId`).
+ * @param {string} [options.endpoint] The record-action endpoint; empty reports nothing.
+ * @param {function(object, object): Promise<void>} [options.report] Sends one decision; defaults to posting to `endpoint`.
+ * @param {number} [options.lifetimeMs] Lifetime of an undecided suggestion.
+ * @param {function(function(): void, number): number} [options.setTimer] Timer factory, for tests.
+ * @param {function(number): void} [options.clearTimer] Timer cancel, for tests.
+ * @return {object} The tracker: show, decide, dismiss, closeAll, pending.
+ */
+export function createSuggestionTracker({
+	objectId,
+	objectKey = 'objectId',
+	endpoint = '',
+	report = (body, options) => (endpoint ? postDecision(endpoint, body, options) : Promise.resolve()),
+	lifetimeMs = SUGGESTION_LIFETIME_MS,
+	setTimer = setTimeout,
+	clearTimer = clearTimeout,
+}) {
+	const pending = new Map()
+	let counter = 0
+
+	/**
+	 * Send the report for one slot's suggestion and forget it.
+	 *
+	 * @param {string} slot The slot key.
+	 * @param {object} decision `{userAction, unusedBecause?, actualValue?, reason?}`.
+	 * @param {object} options Passed to report.
+	 * @return {Promise<void>}
+	 */
+	function settle(slot, decision, options = {}) {
+		const shown = pending.get(slot)
+		if (shown === undefined) {
+			return Promise.resolve()
+		}
+
+		pending.delete(slot)
+		clearTimer(shown.timer)
+		const body = {
+			[objectKey]: objectId,
+			type: shown.type,
+			suggestion: shown.text,
+			prompt: shown.prompt ?? '',
+			model: shown.model ?? '',
+			documentId: shown.documentId ?? '',
+			suggestionId: shown.id,
+			...decision,
+		}
+
+		return Promise.resolve(report(body, options)).catch(() => {
+			// The person's work must not fail because the oversight trail
+			// could not be written; the server logs its own failures.
+		})
+	}
+
+	return {
+		/**
+		 * Register a suggestion as shown in a slot.
+		 *
+		 * @param {string} slot The slot key.
+		 * @param {object} suggestion `{type, text, prompt?, model?, documentId?}`.
+		 * @return {string} The suggestion id.
+		 */
+		show(slot, suggestion) {
+			settle(slot, { userAction: 'ignored', unusedBecause: 'superseded' })
+			counter += 1
+			const id = `${Date.now().toString(36)}-${counter}`
+			const timer = setTimer(() => {
+				settle(slot, { userAction: 'ignored', unusedBecause: 'expired' })
+			}, lifetimeMs)
+			pending.set(slot, { ...suggestion, id, timer })
+			return id
+		},
+
+		/**
+		 * Report the person's decision on a slot's suggestion.
+		 *
+		 * @param {string} slot The slot key.
+		 * @param {string} userAction accepted, modified or rejected.
+		 * @param {object} [extra] `{actualValue?, reason?}`.
+		 * @return {Promise<void>}
+		 */
+		decide(slot, userAction, extra = {}) {
+			return settle(slot, { userAction, ...extra })
+		},
+
+		/**
+		 * Report a slot's undecided suggestion as ignored, for a reason.
+		 *
+		 * @param {string} slot The slot key.
+		 * @param {string} because closed, expired or superseded.
+		 * @return {Promise<void>}
+		 */
+		dismiss(slot, because) {
+			return settle(slot, { userAction: 'ignored', unusedBecause: because })
+		},
+
+		/**
+		 * Report every undecided suggestion as closed.
+		 *
+		 * @param {object} [options] `{leaving}` while the page unloads.
+		 * @return {Promise<void>}
+		 */
+		closeAll(options = {}) {
+			const slots = [...pending.keys()]
+			return Promise.all(slots.map((slot) => settle(
+				slot,
+				{ userAction: 'ignored', unusedBecause: 'closed' },
+				options,
+			))).then(() => undefined)
+		},
+
+		/**
+		 * Whether a slot holds an undecided suggestion.
+		 *
+		 * @param {string} slot The slot key.
+		 * @return {boolean} True while undecided.
+		 */
+		pending(slot) {
+			return pending.has(slot)
+		},
+	}
+}

package/src/utils/libraryWidgetKeys.js

@@ -75,6 +75,7 @@ export const BUILT_IN_WIDGET_KEYS = Object.freeze([
 	'divider',
 	'saved-view-alert',
 	'exports',
+	'object-translations',
 ])
 
 /**