@xopcai/xopc 0.0.313 → 0.0.314

package/dist/src/gateway/hono/routes/voice.js

@@ -2,19 +2,19 @@ import { voiceSelectionSchema } from "../../../../packages/realtime-protocol/src
 import { createVoiceSessionRequestSchema, init_voice } from "../../../../packages/realtime-protocol/src/voice.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../../../providers/index.js";
 import { completeWithResolvedCredentials } from "../../../providers/model-call.js";
-import { resolveTtsProviderConfigSlice } from "../../../voice/tts/config-slice.js";
-import { isTTSAvailable, resolveSpeechProvider } from "../../../voice/tts/factory.js";
-import { speak, speakStream } from "../../../voice/tts/speak-core.js";
-import { mergeTtsConfigFromAppConfig } from "../../../voice/tts/merge-config.js";
-import "../../../voice/tts/index.js";
 import { getLocalVoiceRuntimeClient } from "../../../voice/local/runtime-client.js";
 import { getAudioDecoderStatus } from "../../../voice/audio/normalize.js";
 import { resolveSttProviderConfigSlice } from "../../../voice/stt/config-slice.js";
-import { isSTTAvailable } from "../../../voice/stt/availability.js";
 import { STTTranscriptionError, 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 { resolveTtsProviderConfigSlice } from "../../../voice/tts/config-slice.js";
+import { isTTSAvailable, resolveSpeechProvider } from "../../../voice/tts/factory.js";
+import { speak, speakStream } from "../../../voice/tts/speak-core.js";
+import { mergeTtsConfigFromAppConfig } from "../../../voice/tts/merge-config.js";
 import { listSttProvidersForApi } from "../../../voice/stt/list-providers.js";
+import "../../../voice/tts/index.js";
 import { withModelConfigLock } from "../../../session/model-config-lock.js";
 import { resolveOmniRoute } from "../../../voice/realtime/omniRoute.js";
 import { VoiceSessionCreationError, resolveStreamingStt, resolveStreamingTts } from "../../../voice/realtime/runtime.js";

package/dist/src/gateway/hono/routes/workflows.js

@@ -1,12 +1,12 @@
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
-import { validateWorkflowDefinitionInput } from "../../../workflows/domain/validation.js";
-import { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog } from "../../../agent/workflow/catalog.js";
 import { resolveProjectAgentId } from "../../../projects/project-agent.js";
 import "../../../projects/index.js";
 import { messagesToClientHistory } from "../../../session/client-history.js";
+import { validateWorkflowDefinitionInput } from "../../../workflows/domain/validation.js";
+import { WorkflowDraftService } from "../../../workflows/draft/workflow-draft-service.js";
+import { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog } from "../../../agent/workflow/catalog.js";
 import "../../../workflows/domain/index.js";
 import { resolveWorkflowRunArtifactsDir } from "../../../workflows/store/paths.js";
-import { WorkflowDraftService } from "../../../workflows/draft/workflow-draft-service.js";
 import { WorkflowDraftConflictError, WorkflowDraftStore } from "../../../workflows/authoring/workflow-draft-store.js";
 import "../../../workflows/authoring/index.js";
 import "../../../workflows/draft/index.js";

package/dist/src/gateway/lock.js

@@ -1,9 +1,9 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import path from "node:path";
-import fsSync from "node:fs";
+import fs from "node:fs";
 import { createHash } from "node:crypto";
 import net from "node:net";
-import fs from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 import { homedir } from "os";
 //#region src/gateway/lock.ts
 /**
@@ -19,7 +19,7 @@ function resolveGatewayLockPath(configPath) {
 function isGatewayConfigLockedByAnotherProcessSync(configPath, currentPid = process.pid) {
 	const lockPath = resolveGatewayLockPath(configPath);
 	try {
-		const parsed = JSON.parse(fsSync.readFileSync(lockPath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(lockPath, "utf8"));
 		if (typeof parsed.pid !== "number" || parsed.pid === currentPid || parsed.configPath !== configPath) return false;
 		if (!isPidAlive(parsed.pid)) return false;
 		if (process.platform !== "linux" || !Number.isFinite(parsed.startTime)) return true;
@@ -59,7 +59,7 @@ function isPidAlive(pid) {
 function readLinuxStartTime(pid) {
 	if (process.platform !== "linux") return null;
 	try {
-		const raw = fsSync.readFileSync(`/proc/${pid}/stat`, "utf8").trim();
+		const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8").trim();
 		const closeParen = raw.lastIndexOf(")");
 		if (closeParen < 0) return null;
 		const fields = raw.slice(closeParen + 1).trim().split(/\s+/);
@@ -71,7 +71,7 @@ function readLinuxStartTime(pid) {
 }
 async function readLockPayload(lockPath) {
 	try {
-		const raw = await fs.readFile(lockPath, "utf8");
+		const raw = await fs$1.readFile(lockPath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (typeof parsed.pid !== "number") return null;
 		if (typeof parsed.createdAt !== "string") return null;
@@ -107,11 +107,11 @@ async function acquireGatewayLock(configPath, opts = {}) {
 	const staleMs = opts.staleMs ?? DEFAULT_STALE_MS;
 	const port = opts.port;
 	const lockPath = resolveGatewayLockPath(configPath);
-	await fs.mkdir(path.dirname(lockPath), { recursive: true });
+	await fs$1.mkdir(path.dirname(lockPath), { recursive: true });
 	const startedAt = Date.now();
 	let lastPayload = null;
 	while (Date.now() - startedAt < timeoutMs) try {
-		const handle = await fs.open(lockPath, "wx");
+		const handle = await fs$1.open(lockPath, "wx");
 		const startTime = process.platform === "linux" ? readLinuxStartTime(process.pid) : null;
 		const payload = {
 			pid: process.pid,
@@ -126,7 +126,7 @@ async function acquireGatewayLock(configPath, opts = {}) {
 			configPath,
 			release: async () => {
 				await handle.close().catch(() => void 0);
-				await fs.rm(lockPath, { force: true });
+				await fs$1.rm(lockPath, { force: true });
 				console.log(`[GatewayLock] Lock released: lockPath=${lockPath}`);
 			}
 		};
@@ -137,7 +137,7 @@ async function acquireGatewayLock(configPath, opts = {}) {
 		const ownerStatus = ownerPid ? await resolveOwnerStatus(ownerPid, lastPayload, port) : "unknown";
 		if (ownerStatus === "dead" && ownerPid) {
 			console.warn(`[GatewayLock] Cleaning up stale gateway lock: pid=${ownerPid}`);
-			await fs.rm(lockPath, { force: true });
+			await fs$1.rm(lockPath, { force: true });
 			continue;
 		}
 		if (ownerStatus !== "alive") {
@@ -147,14 +147,14 @@ async function acquireGatewayLock(configPath, opts = {}) {
 				stale = Number.isFinite(createdAt) ? Date.now() - createdAt > staleMs : false;
 			}
 			if (!stale) try {
-				const st = await fs.stat(lockPath);
+				const st = await fs$1.stat(lockPath);
 				stale = Date.now() - st.mtimeMs > staleMs;
 			} catch {
 				stale = false;
 			}
 			if (stale) {
 				console.warn(`[GatewayLock] Removing stale lock file: lockPath=${lockPath}`);
-				await fs.rm(lockPath, { force: true });
+				await fs$1.rm(lockPath, { force: true });
 				continue;
 			}
 		}

package/dist/src/gateway/media-access.js

@@ -1,10 +1,11 @@
-import { TaskContextRepository } from "../tasks/task-context-repository.js";
-import { TaskRepository } from "../tasks/task-repository.js";
+import { TaskRepository, init_task_repository } from "../tasks/task-repository.js";
 import { FileServiceError } from "../files/file-service.js";
 import { resolveMediaReference } from "../media/media-reference.js";
 import { pendingTranscriptReferencesMediaUri } from "../agent/inbound/attachment-pipeline.js";
+import { TaskContextRepository } from "../tasks/task-context-repository.js";
 import { messagesReferenceMediaUri } from "../media/session-references.js";
 //#region src/gateway/media-access.ts
+init_task_repository();
 /** Resolve media only when the supplied session or task references it. */
 async function resolveScopedMediaReference(service, uri, scope) {
 	const { conversationId, taskId } = scope;

package/dist/src/gateway/mobile-privacy.js

@@ -1,9 +1,9 @@
 import { getProviderRegistry, init_plugin_registry } from "../providers/plugin-registry.js";
 import { PROVIDER_META, getAvailableModels, init_providers } from "../providers/index.js";
-import { resolveSpeechProviderChain } from "../voice/tts/factory.js";
-import { mergeTtsConfigFromAppConfig } from "../voice/tts/merge-config.js";
 import { resolveSTTProviderChain } from "../voice/stt/factory.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
+import { resolveSpeechProviderChain } from "../voice/tts/factory.js";
+import { mergeTtsConfigFromAppConfig } from "../voice/tts/merge-config.js";
 import { getVoiceProviderMetadata } from "../voice/metadata/registry.js";
 import "../voice/metadata/index.js";
 import { getImageGenerationCatalog } from "./image-generation-setup.js";

package/dist/src/gateway/ports.js

@@ -1,6 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import fsSync from "node:fs";
+import fs from "node:fs";
 import { execFileSync } from "node:child_process";
 import net from "node:net";
 //#region src/gateway/ports.ts
@@ -54,7 +54,7 @@ function listPortListenersViaProc(port) {
 	for (const procFile of ["/proc/net/tcp", "/proc/net/tcp6"]) {
 		let content;
 		try {
-			content = fsSync.readFileSync(procFile, "utf-8");
+			content = fs.readFileSync(procFile, "utf-8");
 		} catch {
 			continue;
 		}
@@ -68,7 +68,7 @@ function listPortListenersViaProc(port) {
 	if (inodeSet.size === 0) return results;
 	let pidDirs;
 	try {
-		pidDirs = fsSync.readdirSync("/proc").filter((name) => /^\d+$/.test(name));
+		pidDirs = fs.readdirSync("/proc").filter((name) => /^\d+$/.test(name));
 	} catch {
 		return results;
 	}
@@ -76,14 +76,14 @@ function listPortListenersViaProc(port) {
 		const fdDir = `/proc/${pidStr}/fd`;
 		let fds;
 		try {
-			fds = fsSync.readdirSync(fdDir);
+			fds = fs.readdirSync(fdDir);
 		} catch {
 			continue;
 		}
 		for (const fd of fds) {
 			let target;
 			try {
-				target = fsSync.readlinkSync(`${fdDir}/${fd}`);
+				target = fs.readlinkSync(`${fdDir}/${fd}`);
 			} catch {
 				continue;
 			}
@@ -93,7 +93,7 @@ function listPortListenersViaProc(port) {
 			if (!results.some((p) => p.pid === pid)) {
 				let command;
 				try {
-					command = fsSync.readFileSync(`/proc/${pidStr}/comm`, "utf-8").trim();
+					command = fs.readFileSync(`/proc/${pidStr}/comm`, "utf-8").trim();
 				} catch {}
 				results.push({
 					pid,

package/dist/src/gateway/scenes/host.js

@@ -2,8 +2,9 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { assertSceneStorageReady, init_scenes_schema } from "../../storage/sqlite/scenes-schema.js";
 import { init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
-import { BrowserSubscriptionService } from "../../notifications/browserSubscriptions.js";
 import { SceneRepository } from "../../scenes/repository.js";
+import { SceneApplicationService } from "../../scenes/service.js";
+import { BrowserSubscriptionService } from "../../notifications/browserSubscriptions.js";
 import { ScenePreferenceService } from "../../scenes/preferences.js";
 import { SceneExecutionService } from "../../scenes/execution.js";
 import { SceneAgentExecutor } from "../../scenes/agentExecutor.js";
@@ -14,11 +15,13 @@ import { SceneMetrics } from "../../scenes/metrics.js";
 import { resolveSceneModelRef } from "../../scenes/model.js";
 import { SceneResultNotifications } from "../../scenes/resultNotifications.js";
 import { SceneRuntime } from "../../scenes/runtime.js";
-import { SceneApplicationService } from "../../scenes/service.js";
 import { familyPlanTemplate, mailFollowUpTemplate } from "../../scenes/templates.js";
 import { SceneUserNotesProvider } from "../../scenes/userNotes.js";
 import { createSceneBrowserDispatcher } from "./browserNotifications.js";
 import { GatewaySceneMailContext } from "./mailContext.js";
+import { SlackThreadSource } from "./slackThreadSource.js";
+import { TaskSourceRegistry } from "../../scenes/taskFollowUp/contracts.js";
+import { TaskFollowUpService } from "../../scenes/taskFollowUp/service.js";
 //#region src/gateway/scenes/host.ts
 init_providers();
 init_scenes_schema();
@@ -61,7 +64,13 @@ var GatewaySceneHost = class {
 		};
 		const grant = async (activation) => authorize(activation);
 		const executor = input.executor ?? new SceneAgentExecutor(() => resolveModel(resolveSceneModelRef(input.config())));
+		const slackThread = new SlackThreadSource(db);
+		const followUps = new TaskFollowUpService(db, {
+			config: input.config,
+			sources: new TaskSourceRegistry([slackThread])
+		});
 		this.http = {
+			followUps,
 			repository,
 			mail,
 			mailDiscovery: mail instanceof GatewaySceneMailContext ? mail : void 0,
@@ -90,6 +99,7 @@ var GatewaySceneHost = class {
 		assertSceneStorageReady(this.db);
 		this.runtime.start();
 		const poll = () => {
+			this.http.followUps?.tick().catch((err) => log.error({ err }, "Task follow-up check failed"));
 			try {
 				if (this.clock() >= this.nextMaintenanceAt) {
 					maintainSceneStorage(this.db, this.clock());
@@ -108,7 +118,7 @@ var GatewaySceneHost = class {
 	tick() {
 		if (this.stopped) return Promise.reject(/* @__PURE__ */ new Error("Scene host stopped"));
 		if (this.active) return this.active;
-		const work = this.runtime.tick().then(() => {
+		const work = Promise.all([this.runtime.tick(), this.http.followUps?.tick()]).then(() => {
 			if (!this.stopped) this.notifications.drain();
 		});
 		this.active = work.finally(() => {
@@ -121,6 +131,7 @@ var GatewaySceneHost = class {
 		this.stopped = true;
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
+		await this.http.followUps?.stop();
 		await this.runtime.stop();
 		await this.browserDispatcher.stop();
 		await this.active?.catch(() => void 0);

package/dist/src/gateway/scenes/mailContext.js

@@ -1,9 +1,9 @@
 import { getConnectorConnection, getConnectorInstallation, init_connector_repository } from "../../storage/sqlite/connector-repository.js";
 import { ComposioSessionsAdapter } from "../../connectors/composio-sessions.js";
 import { getConnectorDefinition } from "../../connectors/catalog.js";
+import { sceneContentHash } from "../../scenes/contracts.js";
 import { normalizeConnectedSourceResult } from "../../connectors/connected-source-normalizers.js";
 import { sanitizeConnectedSourceValue } from "../../connectors/connected-source-sanitization.js";
-import { sceneContentHash } from "../../scenes/contracts.js";
 import { SceneSourceNotReady, sceneSourceFailureReason } from "../../scenes/readiness.js";
 import { SceneMailContextProvider } from "../../scenes/mailContext.js";
 import { createHash } from "node:crypto";

package/dist/src/gateway/scenes/slackThreadSource.d.ts

@@ -0,0 +1,41 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { z } from 'zod';
+import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
+import { type ScenePrincipal } from '../../scenes/contracts.js';
+import type { TaskSourceAdapter, SourceSnapshot } from '../../scenes/taskFollowUp/contracts.js';
+export declare const slackThreadSchema: z.ZodObject<{
+    accountId: z.ZodString;
+    teamId: z.ZodString;
+    channelId: z.ZodString;
+    threadTs: z.ZodString;
+}, z.core.$strict>;
+export type SlackThread = z.infer<typeof slackThreadSchema>;
+/** Parse locally; never fetch a user-supplied URL. Reply links resolve to their root. */
+export declare function parseSlackThreadUrl(value: string): {
+    channelId: string;
+    threadTs: string;
+};
+/** Read-only connector adapter. Account policy is rechecked before and after every page. */
+export declare class SlackThreadSource implements TaskSourceAdapter {
+    private readonly db;
+    private readonly adapter;
+    readonly id = "slack_thread";
+    readonly label = "Slack thread";
+    normalize(reference: Record<string, string>): {
+        accountId: string;
+        teamId: string;
+        channelId: string;
+        threadTs: string;
+    };
+    accountIds(reference: Record<string, string>): string[];
+    authorized(principal: ScenePrincipal, reference: Record<string, string>): boolean;
+    constructor(db: DatabaseSync, adapter?: Pick<ComposioSessionsAdapter, 'executeWithPolicy'>);
+    listAccounts(principal: ScenePrincipal): Array<{
+        id: string;
+        label: string;
+    }>;
+    private connection;
+    private call;
+    resolveLink(principal: ScenePrincipal, accountId: string, url: string, signal: AbortSignal): Promise<SlackThread>;
+    read(principal: ScenePrincipal, reference: Record<string, string>, signal: AbortSignal): Promise<SourceSnapshot>;
+}

package/dist/src/gateway/scenes/slackThreadSource.js

@@ -0,0 +1,168 @@
+import { getConnectorConnection, getConnectorInstallation, init_connector_repository } from "../../storage/sqlite/connector-repository.js";
+import { ComposioSessionsAdapter } from "../../connectors/composio-sessions.js";
+import { getConnectorDefinition } from "../../connectors/catalog.js";
+import { sceneContentHash } from "../../scenes/contracts.js";
+import { sanitizeConnectedSourceValue } from "../../connectors/connected-source-sanitization.js";
+import { z } from "zod";
+//#region src/gateway/scenes/slackThreadSource.ts
+init_connector_repository();
+const slackThreadSchema = z.strictObject({
+	accountId: z.string().min(1).max(200),
+	teamId: z.string().regex(/^T[A-Z0-9]+$/),
+	channelId: z.string().regex(/^[CDG][A-Z0-9]+$/),
+	threadTs: z.string().regex(/^\d{10,}\.\d{6}$/)
+});
+/** Parse locally; never fetch a user-supplied URL. Reply links resolve to their root. */
+function parseSlackThreadUrl(value) {
+	const url = new URL(value);
+	if (url.protocol !== "https:" || !/^[a-z0-9-]+\.slack\.com$/.test(url.hostname) || url.username || url.password || url.port) throw new Error("Expected a Slack message link");
+	const match = /^\/archives\/([CDG][A-Z0-9]+)\/p(\d{16,})$/.exec(url.pathname);
+	if (!match) throw new Error("Expected a Slack message link");
+	const threadTs = url.searchParams.get("thread_ts") ?? `${match[2].slice(0, -6)}.${match[2].slice(-6)}`;
+	if (!/^\d{10,}\.\d{6}$/.test(threadTs)) throw new Error("Invalid Slack thread timestamp");
+	return {
+		channelId: match[1],
+		threadTs
+	};
+}
+const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+/** Read-only connector adapter. Account policy is rechecked before and after every page. */
+var SlackThreadSource = class {
+	id = "slack_thread";
+	label = "Slack thread";
+	normalize(reference) {
+		return slackThreadSchema.parse(reference);
+	}
+	accountIds(reference) {
+		return [this.normalize(reference).accountId];
+	}
+	authorized(principal, reference) {
+		return this.listAccounts(principal).some((account) => account.id === this.normalize(reference).accountId);
+	}
+	constructor(db, adapter = new ComposioSessionsAdapter()) {
+		this.db = db;
+		this.adapter = adapter;
+	}
+	listAccounts(principal) {
+		return this.db.prepare(`SELECT a.id, a.label, c.connector_id FROM connector_accounts a
+      JOIN connector_connections c ON c.id = a.current_connection_id AND c.account_id = a.id
+        AND c.principal_id = a.principal_id AND c.connector_id = a.connector_id
+      JOIN connector_installations i ON i.id = c.installation_id AND i.principal_id = a.principal_id AND i.connector_id = a.connector_id
+      WHERE a.principal_id = ? AND a.enabled = 1 AND c.status = 'active' AND c.provider = 'composio'
+        AND i.enabled = 1 AND i.confirmation_policy <> 'always'
+        AND json_array_length(i.allowed_agent_ids_json) = 0 AND a.allowed_agent_ids_json IS NULL
+        AND (i.selected_account_ids_json = 'null' OR EXISTS (SELECT 1 FROM json_each(i.selected_account_ids_json) WHERE value = a.id))
+        AND (c.expires_at IS NULL OR julianday(c.expires_at) > julianday('now')) ORDER BY a.id LIMIT 100`).all(principal.ownerId).filter((row) => {
+			const definition = getConnectorDefinition(String(row.connector_id));
+			return definition?.runtime.type === "composio" && definition.runtime.toolkit === "slack";
+		}).map((row) => ({
+			id: String(row.id),
+			label: String(row.label || row.id).slice(0, 300)
+		}));
+	}
+	connection(principal, accountId) {
+		if (!this.listAccounts(principal).some((account) => account.id === accountId)) throw new Error("Slack account permission unavailable");
+		const row = this.db.prepare("SELECT current_connection_id FROM connector_accounts WHERE id = ?").get(accountId);
+		return getConnectorConnection(String(row.current_connection_id));
+	}
+	async call(principal, accountId, actionId, args, signal) {
+		signal.throwIfAborted();
+		const connection = this.connection(principal, accountId);
+		const installation = getConnectorInstallation(connection.installationId);
+		const day = Math.floor(Date.now() / 864e5);
+		const usage = this.db.prepare("SELECT request_count FROM scene_connector_usage WHERE owner_id = ? AND workspace_id = ? AND account_id = ? AND utc_day = ?").get(principal.ownerId, principal.workspaceId, accountId, day);
+		if (Number(usage?.request_count ?? 0) >= 3e3) throw new Error("Slack daily request budget exhausted");
+		this.db.prepare(`INSERT INTO scene_connector_usage VALUES (?, ?, ?, ?, 1)
+      ON CONFLICT(owner_id, workspace_id, account_id, utc_day) DO UPDATE SET request_count = request_count + 1`).run(principal.ownerId, principal.workspaceId, accountId, day);
+		const result = await this.adapter.executeWithPolicy({
+			context: {
+				principalId: principal.ownerId,
+				toolkits: ["slack"]
+			},
+			connection,
+			installation,
+			signal,
+			args,
+			action: {
+				connectorId: connection.connectorId,
+				toolkit: "slack",
+				actionId,
+				scope: "read",
+				curated: true,
+				cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		});
+		signal.throwIfAborted();
+		if (this.connection(principal, accountId).id !== connection.id) throw new Error("Slack connection changed");
+		if (result.decision !== "allowed") throw new Error("Slack read requires permission");
+		const envelope = object(result.result);
+		const data = object(envelope.data);
+		if (envelope.successful === false || envelope.error || data.ok === false || data.error || !Object.keys(data).length) throw new Error("Slack source unavailable; check connection permissions or rate limit");
+		return data;
+	}
+	async resolveLink(principal, accountId, url, signal) {
+		const parsed = parseSlackThreadUrl(url);
+		const auth = await this.call(principal, accountId, "SLACK_TEST_AUTH", {}, signal);
+		if (typeof auth.team_id !== "string" || !/^T[A-Z0-9]+$/.test(auth.team_id)) throw new Error("Slack workspace identity unavailable");
+		return {
+			accountId,
+			teamId: auth.team_id,
+			...parsed
+		};
+	}
+	async read(principal, reference, signal) {
+		const thread = this.normalize(reference);
+		if ((await this.call(principal, thread.accountId, "SLACK_TEST_AUTH", {}, signal)).team_id !== thread.teamId) throw new Error("Slack workspace identity changed");
+		const messages = /* @__PURE__ */ new Map();
+		const cursors = /* @__PURE__ */ new Set();
+		let cursor;
+		do {
+			const data = await this.call(principal, thread.accountId, "SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION", {
+				channel: thread.channelId,
+				ts: thread.threadTs,
+				limit: 100,
+				...cursor ? { cursor } : {}
+			}, signal);
+			if (!Array.isArray(data.messages) || !data.messages.length) throw new Error("Slack thread is missing or incomplete");
+			for (const item of data.messages) {
+				const message = object(item);
+				if (typeof message.ts !== "string" || typeof message.text !== "string" || message.ts !== thread.threadTs && message.thread_ts !== thread.threadTs) throw new Error("Unexpected Slack thread response");
+				messages.set(message.ts, {
+					ts: message.ts,
+					user: String(message.user ?? message.bot_id ?? "unknown"),
+					text: String(sanitizeConnectedSourceValue(message.text)),
+					...Array.isArray(message.files) && message.files.length || Array.isArray(message.attachments) && message.attachments.length ? { unreadAttachments: sanitizeConnectedSourceValue({
+						files: Array.isArray(message.files) ? message.files.slice(0, 20).map((value) => {
+							const file = object(value);
+							return {
+								id: file.id,
+								name: file.name,
+								mimetype: file.mimetype
+							};
+						}) : [],
+						richMessageCount: Array.isArray(message.attachments) ? message.attachments.length : 0,
+						contentFetched: false
+					}) } : {}
+				});
+			}
+			if (messages.size > 200) throw new Error("Slack thread exceeds the 200-message context budget");
+			const next = object(data.response_metadata).next_cursor;
+			if (next != null && typeof next !== "string") throw new Error("Invalid Slack pagination");
+			cursor = typeof next === "string" && next.trim() ? next.trim() : void 0;
+			if (data.has_more === true && !cursor) throw new Error("Slack thread pagination is incomplete");
+			if (cursor && (cursors.has(cursor) || cursors.size >= 9)) throw new Error("Slack pagination budget exceeded");
+			if (cursor) cursors.add(cursor);
+		} while (cursor);
+		if (!messages.has(thread.threadTs)) throw new Error("Select the root of the Slack thread");
+		const ordered = [...messages.values()].sort((a, b) => a.ts.localeCompare(b.ts));
+		const text = JSON.stringify(ordered);
+		if (text.length > 32e3) throw new Error("Slack thread exceeds the 32,000-character context budget");
+		return {
+			revision: sceneContentHash(ordered),
+			text,
+			observedAt: Date.now()
+		};
+	}
+};
+//#endregion
+export { SlackThreadSource, parseSlackThreadUrl, slackThreadSchema };

package/dist/src/gateway/security/gateway-scopes.d.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_BROWSER_EXTENSION_SCOPES, DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, isGatewayScope, type GatewayScope } from '@xopcai/gateway-contract';
 export { DEFAULT_BROWSER_EXTENSION_SCOPES, DEFAULT_MOBILE_SCOPES, GATEWAY_SCOPES, isGatewayScope, type GatewayScope, };
 export declare function parseGatewayScopes(value: string): GatewayScope[];
-export declare function requiredGatewayScope(method: string, path: string): GatewayScope;
+export declare function requiredGatewayScope(method: string, path: string): GatewayScope | undefined;
 export declare function hasGatewayScope(granted: readonly GatewayScope[], required: GatewayScope): boolean;

package/dist/src/gateway/security/gateway-scopes.js

@@ -11,6 +11,8 @@ function methodScope(method, read, write) {
 	return method === "GET" ? read : write;
 }
 function requiredGatewayScope(method, path) {
+	if (/^\/api\/local-app-capabilities\/[^/]+(?:\/[^/]+\/invocations)?$/.test(path)) return void 0;
+	if (path === "/api/capabilities/operations" || path.startsWith("/api/capabilities/operations/")) return void 0;
 	if (method === "GET" && path === "/api/mobile/privacy") return "gateway.status";
 	if (path === "/api/realtime/tickets" || path.startsWith("/api/status")) return "gateway.status";
 	if (path === "/api/device-auth/refresh" || path === "/api/devices/me") return "device.self";
@@ -23,7 +25,10 @@ function requiredGatewayScope(method, path) {
 	if (path.startsWith("/api/agents") || path.startsWith("/api/models")) return methodScope(method, "agents.read", "gateway.admin");
 	if (path.startsWith("/api/sessions") || path.startsWith("/api/side-chats")) return methodScope(method, "sessions.read", "sessions.write");
 	if (path.startsWith("/api/tasks")) return methodScope(method, "tasks.read", "tasks.write");
+	if (path === "/api/task-runs" || path.startsWith("/api/task-runs/")) return methodScope(method, "tasks.read", "tasks.write");
 	if (path.startsWith("/api/home") || path.startsWith("/api/inbox")) return methodScope(method, "tasks.read", "tasks.write");
+	if (method === "POST" && path === "/api/automations/simulate") return "automations.read";
+	if (method === "POST" && /^\/api\/notes\/[^/]+\/ai\/edit$/.test(path)) return "workspace.read";
 	if (path.startsWith("/api/automations") || path.startsWith("/api/automation-runs")) return methodScope(method, "automations.read", "automations.write");
 	if (path.startsWith("/api/workflows")) return methodScope(method, "automations.read", "automations.write");
 	if (path === "/api/voice/selection" || path === "/api/voice/catalog/refresh") return "voice.configure";

package/dist/src/gateway/server.js

@@ -1,5 +1,5 @@
-import { ensureXopcCliOnPath } from "../infra/path-env.js";
 import { resolveGatewayBindHost, resolveGatewayListenHosts } from "../config/gateway-bind.js";
+import { ensureXopcCliOnPath } from "../infra/path-env.js";
 import { resolveGatewayListenPlan } from "./listen.js";
 import { GatewayService } from "./service.js";
 import { handleSiteShareUpgrade } from "../share/site-share-router.js";

package/dist/src/gateway/service/app-context-access.d.ts

@@ -0,0 +1,11 @@
+import type { AgentSourceContext } from '../../agent/source-context/types.js';
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import type { ResolvedGatewayAuth } from '../auth.js';
+import type { GatewayPrincipal } from '../security/gateway-principal.js';
+export interface AppContextGrant {
+    principal: GatewayPrincipal;
+    authRevision: string;
+}
+/** A queued read retains its original scope ceiling, but never a revoked identity. */
+export declare function checkAppContextAccess(source: AgentSourceContext, dispatcher: CapabilityDispatcher, auth: ResolvedGatewayAuth): Promise<void>;
+export declare function prepareAppContext(input: unknown, principal: GatewayPrincipal, auth: ResolvedGatewayAuth, dispatcher: CapabilityDispatcher, previous?: AgentSourceContext): Promise<AgentSourceContext>;

package/dist/src/gateway/service/app-context-access.js

@@ -0,0 +1,70 @@
+import { parseAppContextEnvelope } from "../../../packages/gateway-contract/src/app-context.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { getDevice } from "../../storage/sqlite/device-access-repository.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { canonicalCapabilityJson } from "../../capabilities/runtime/dispatcher.js";
+import { isBrowserSessionActive } from "../../storage/sqlite/browser-session-repository.js";
+import { appContextToAgentContext } from "../../agent/source-context/app-context.js";
+import { createHmac, randomBytes } from "node:crypto";
+//#region src/gateway/service/app-context-access.ts
+init_src();
+const authorizationEpochKey = randomBytes(32);
+function authRevision(auth) {
+	return createHmac("sha256", authorizationEpochKey).update(canonicalCapabilityJson(JSON.parse(JSON.stringify(auth)))).digest("hex");
+}
+/** A queued read retains its original scope ceiling, but never a revoked identity. */
+async function checkAppContextAccess(source, dispatcher, auth) {
+	const grant = source.appContextGrant;
+	if (!grant || grant.authRevision !== authRevision(auth) || !source.appContext) throw new CapabilityError("FORBIDDEN", "Application context authorization changed");
+	const { principal } = grant;
+	let scopes = principal.scopes;
+	if (principal.kind === "device") {
+		const device = principal.deviceId ? getDevice(principal.deviceId) : void 0;
+		if (!device || device.revokedAt !== void 0 || device.id !== principal.principalId) throw new CapabilityError("FORBIDDEN", "Application context device access was revoked");
+		scopes = scopes.filter((scope) => device.scopes.includes(scope));
+	}
+	if (principal.browserSessionId && !isBrowserSessionActive(principal.browserSessionId, auth)) throw new CapabilityError("FORBIDDEN", "Application context browser session ended");
+	for (const ref of source.appContext.resourceRefs) {
+		const domain = ref.kind === "local_app" ? "local_apps" : `${ref.kind}s`;
+		await dispatcher.call(`xopc.${domain}.get`, { id: ref.id }, {
+			principalId: principal.principalId,
+			scopes,
+			surface: "http",
+			authorize: () => true
+		});
+	}
+}
+async function prepareAppContext(input, principal, auth, dispatcher, previous) {
+	let snapshot;
+	try {
+		snapshot = parseAppContextEnvelope(input);
+	} catch {
+		throw new CapabilityError("INVALID_INPUT", "Invalid application context envelope");
+	}
+	const grant = {
+		principal: structuredClone(principal),
+		authRevision: authRevision(auth)
+	};
+	if (previous) {
+		if (canonicalCapabilityJson(previous.appContext) !== canonicalCapabilityJson(snapshot) || previous.appContextGrant?.principal.principalId !== principal.principalId) throw new CapabilityError("REVISION_CONFLICT", "Submission identity already belongs to another context");
+		await checkAppContextAccess(previous, dispatcher, auth);
+		await checkAppContextAccess({
+			...previous,
+			appContextGrant: grant
+		}, dispatcher, auth);
+		return structuredClone(previous);
+	}
+	const source = {
+		...appContextToAgentContext(await dispatcher.call("xopc.context.resolve", snapshot, {
+			principalId: principal.principalId,
+			scopes: principal.scopes,
+			surface: "http",
+			authorize: () => true
+		})),
+		appContextGrant: grant
+	};
+	await checkAppContextAccess(source, dispatcher, auth);
+	return source;
+}
+//#endregion
+export { checkAppContextAccess, prepareAppContext };

package/dist/src/gateway/service/config-coordinator.js

@@ -1,15 +1,15 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { getModelRegistry } from "../../providers/model-registry.js";
 import { loadConfig, saveConfig } from "../../config/loader.js";
+import { getModelRegistry } from "../../providers/model-registry.js";
 import { init_providers } from "../../providers/index.js";
+import { disposeAllSessionMcpRuntimes } from "../../agent/mcp/bundle-mcp-runtime.js";
+import { reloadImageGenerationProviders } from "../../agent/image/generation/provider-registry.js";
+import "../../agent/mcp/bundle-mcp-tools.js";
 import { ConfigHotReloader } from "../../config/reload.js";
 import "../../config/index.js";
 import { validateComputerModelChanges } from "../../computer/model-config.js";
-import { disposeAllSessionMcpRuntimes } from "../../agent/mcp/bundle-mcp-runtime.js";
 import { computeBundledExtensionExtensionsPatch } from "../../extensions/bundled-extension-activation.js";
-import { reloadImageGenerationProviders } from "../../agent/image/generation/provider-registry.js";
-import "../../agent/mcp/bundle-mcp-tools.js";
 import { sanitizeTunnelConfig } from "../../tunnel/tunnel-config.js";
 //#region src/gateway/service/config-coordinator.ts
 init_providers();