@xopcai/xopc 0.0.177 → 0.0.179

package/dist/src/proactive/temporal/worker.js

@@ -0,0 +1,110 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { listKnowledgeSourceItems } from "../../storage/sqlite/knowledge-repository.js";
+import { getConnectorSyncPolicy } from "../../storage/sqlite/connector-sync-policy-repository.js";
+//#region src/proactive/temporal/worker.ts
+init_logger();
+const log = createLogger("Proactive:Temporal");
+const MEETING_SCENARIO = "meeting_preparation";
+function metadataString(metadata, key) {
+	const value = metadata[key];
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function meetingWindow(startMs, nowMs) {
+	const untilStart = startMs - nowMs;
+	if (untilStart <= 0) return null;
+	if (untilStart <= 120 * 6e4) return "2h";
+	if (untilStart <= 1440 * 6e4) return "24h";
+	return null;
+}
+var ProactiveTemporalWorker = class {
+	timer = null;
+	running = false;
+	constructor(events, intervalMs = 6e4) {
+		this.events = events;
+		this.intervalMs = intervalMs;
+	}
+	start() {
+		if (this.timer) return;
+		this.tick();
+		this.timer = setInterval(() => void this.tick(), Math.max(5e3, this.intervalMs));
+		this.timer.unref?.();
+	}
+	stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+	}
+	async tick(now = /* @__PURE__ */ new Date()) {
+		if (this.running) return {
+			scanned: 0,
+			published: 0,
+			skipped: 0
+		};
+		this.running = true;
+		const result = {
+			scanned: 0,
+			published: 0,
+			skipped: 0
+		};
+		try {
+			const nowMs = now.getTime();
+			const pageSize = 500;
+			for (let offset = 0;; offset += pageSize) {
+				const items = listKnowledgeSourceItems({
+					itemType: "calendar_event",
+					occurredAfterMs: nowMs,
+					occurredBeforeMs: nowMs + 1440 * 6e4,
+					orderBy: "occurred_asc",
+					limit: pageSize,
+					offset
+				});
+				for (const item of items) {
+					result.scanned += 1;
+					const connectionId = metadataString(item.metadata, "connectionId");
+					const workspaceId = metadataString(item.metadata, "workspaceId");
+					const connectorId = metadataString(item.metadata, "connectorId");
+					const agentId = metadataString(item.metadata, "agentId");
+					const window = meetingWindow(item.occurredAt ? Date.parse(item.occurredAt) : NaN, nowMs);
+					const policy = connectionId ? getConnectorSyncPolicy(connectionId) : void 0;
+					const scenarioAllowed = !policy?.allowedScenarioKeys.length || policy.allowedScenarioKeys.includes(MEETING_SCENARIO);
+					if (!connectionId || !workspaceId || !connectorId || !window || !policy?.scanEnabled || !policy.proactiveEnabled || !scenarioAllowed || item.sensitivity === "secret" || item.sensitivity === "regulated") {
+						result.skipped += 1;
+						continue;
+					}
+					if (this.events.publish({
+						type: "connected_source.calendar_window.v1",
+						schemaVersion: 1,
+						source: {
+							kind: "connector",
+							id: connectionId
+						},
+						subject: {
+							kind: "knowledge_source_item",
+							id: item.id
+						},
+						actor: { kind: "system" },
+						scope: {
+							workspaceId,
+							...agentId ? { agentId } : {}
+						},
+						occurredAt: now.toISOString(),
+						dedupeKey: `calendar-window:${item.id}:${item.occurredAt}:${window}`,
+						sensitivity: item.sensitivity === "normal" ? "personal" : item.sensitivity,
+						payload: {
+							sourceItemId: item.id,
+							meetingStartsAt: item.occurredAt,
+							window
+						}
+					}, now).inserted) result.published += 1;
+				}
+				if (items.length < pageSize) break;
+			}
+			if (result.published > 0) log.info(result, "Temporal meeting signals published");
+			return result;
+		} finally {
+			this.running = false;
+		}
+	}
+};
+//#endregion
+export { ProactiveTemporalWorker };

package/dist/src/providers/provider-auth-service.js

@@ -2,11 +2,13 @@ import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_paths, resolveModelsJsonPath } from "../config/paths.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { XopcModelCredentialStore, init_model_credential_store } from "../auth/model-credential-store.js";
+import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "./register-bundled-oauth-flows.js";
 import { init_register_runtime_providers, registerRuntimeProviders } from "./register-runtime-providers.js";
 import { InMemoryModelsStore } from "@earendil-works/pi-ai";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 //#region src/providers/provider-auth-service.ts
 async function createAuthRuntime(credentials) {
+	registerBundledOAuthFlows();
 	const runtime = await ModelRuntime.create({
 		credentials,
 		modelsPath: resolveModelsJsonPath(),
@@ -32,6 +34,7 @@ var init_provider_auth_service = __esmMin((() => {
 	init_credentials();
 	init_model_credential_store();
 	init_paths();
+	init_register_bundled_oauth_flows();
 	init_register_runtime_providers();
 	ProviderAuthService = class {
 		credentials;

package/dist/src/providers/register-bundled-oauth-flows.d.ts

@@ -0,0 +1,2 @@
+/** Statically include pi-ai OAuth flows for single-file runtimes such as Electron. */
+export declare function registerBundledOAuthFlows(): void;

package/dist/src/providers/register-bundled-oauth-flows.js

@@ -0,0 +1,16 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
+//#region src/providers/register-bundled-oauth-flows.ts
+/** Statically include pi-ai OAuth flows for single-file runtimes such as Electron. */
+function registerBundledOAuthFlows() {
+	if (registered) return;
+	registerBunOAuthFlows();
+	registered = true;
+}
+var registered;
+var init_register_bundled_oauth_flows = __esmMin((() => {
+	registered = false;
+}));
+//#endregion
+init_register_bundled_oauth_flows();
+export { init_register_bundled_oauth_flows, registerBundledOAuthFlows };

package/dist/src/session/store.d.ts

@@ -26,6 +26,7 @@ export interface SessionCompactionHooks {
         compactedCount: number;
     }) => Promise<void> | void;
 }
+export type ModelFallbackPreparation = 'prompt' | 'resume' | 'unsafe';
 export declare class SessionStore {
     private options;
     private window;
@@ -78,6 +79,7 @@ export declare class SessionStore {
     private buildSessionDetail;
     loadTranscriptRows(key: string): Promise<TranscriptStoredRow[]>;
     loadTranscriptHistoryRows(key: string): Promise<TranscriptStoredRow[]>;
+    prepareModelFallback(key: string, rowsBeforeAttempt: readonly TranscriptStoredRow[]): Promise<ModelFallbackPreparation>;
     getMetadata(key: string): Promise<SessionMetadata | null>;
     resolveKeyBySessionId(sessionId: string): Promise<string | null>;
     updateMetadata(key: string, updates: Partial<SessionMetadata>): Promise<void>;

package/dist/src/session/store.js

@@ -21,6 +21,16 @@ init_paths_state();
 init_logger();
 const log = createLogger("SessionStore");
 const INDEX_VERSION = "1.0";
+function isTranscriptMessageRole(row, role) {
+	return !!row && typeof row === "object" && "role" in row && row.role === role;
+}
+function isErrorAssistantRow(row) {
+	return isTranscriptMessageRole(row, "assistant") && row.stopReason === "error";
+}
+function transcriptPrefixMatches(expected, current) {
+	if (current.length < expected.length) return false;
+	return expected.every((row, index) => JSON.stringify(row) === JSON.stringify(current[index]));
+}
 var SessionStore = class {
 	window;
 	compactor;
@@ -186,6 +196,26 @@ var SessionStore = class {
 		requireXopcDatabase();
 		return loadTranscriptHistoryRowsForSession(key);
 	}
+	async prepareModelFallback(key, rowsBeforeAttempt) {
+		return this.runStoreMutation(async () => {
+			requireXopcDatabase();
+			const currentRows = loadTranscriptRowsForSession(key);
+			if (!transcriptPrefixMatches(rowsBeforeAttempt, currentRows)) return "unsafe";
+			let preparedRows = currentRows;
+			let removedError = false;
+			if (isErrorAssistantRow(preparedRows.at(-1))) {
+				preparedRows = preparedRows.slice(0, -1);
+				removedError = true;
+			}
+			const appendedRows = preparedRows.slice(rowsBeforeAttempt.length);
+			if (appendedRows.length === 1 && isTranscriptMessageRole(appendedRows[0], "user") || removedError && appendedRows.length === 0 && isTranscriptMessageRole(preparedRows.at(-1), "user")) {
+				if (removedError) replaceTranscriptRows(key, preparedRows);
+				return "resume";
+			}
+			if (!removedError && appendedRows.length === 0) return "prompt";
+			return "unsafe";
+		});
+	}
 	async getMetadata(key) {
 		requireXopcDatabase();
 		return getSessionMetadata(key);

package/dist/src/share/share-zip.js

@@ -2,8 +2,8 @@ import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { relative, resolve } from "node:path";
 import { createReadStream } from "node:fs";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
-import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable, Transform } from "node:stream";
 import { crc32, createDeflateRaw } from "node:zlib";
 //#region src/share/share-zip.ts
 const SIG_LOCAL = 67324752;

package/dist/src/share/site-proxy.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { request } from "undici";
 import { Readable } from "node:stream";
+import { request } from "undici";
 import * as ws from "ws";
 //#region src/share/site-proxy.ts
 init_logger();

package/dist/src/storage/sqlite/activity-repository.d.ts

@@ -6,3 +6,4 @@ export declare function listObjectActivityRecords(options: ListObjectActivityOpt
 export declare function listProjectActivityRecords(options: ListProjectActivityOptions): ActivityListResult;
 export declare function createObjectLinkRecord(input: CreateObjectLinkInput): ObjectLink;
 export declare function listObjectLinkRecords(object: ActivityObjectRef): ObjectLink[];
+export declare function deleteObjectLinkRecord(id: string): boolean;

package/dist/src/storage/sqlite/activity-repository.js

@@ -202,5 +202,8 @@ function listObjectLinkRecords(object) {
        WHERE (from_kind = ? AND from_id = ?) OR (to_kind = ? AND to_id = ?)
        ORDER BY created_at DESC, id DESC`).all(object.kind, object.id, object.kind, object.id).map((row) => objectLinkFromRow(row));
 }
+function deleteObjectLinkRecord(id) {
+	return runSqliteWriteTransaction((db) => db.prepare("DELETE FROM object_links WHERE id = ?").run(id).changes > 0);
+}
 //#endregion
-export { createObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent };
+export { createObjectLinkRecord, deleteObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent };

package/dist/src/storage/sqlite/connector-sync-policy-repository.d.ts

@@ -0,0 +1,20 @@
+export type ConnectorSyncPolicy = {
+    connectionId: string;
+    scanEnabled: boolean;
+    proactiveEnabled: boolean;
+    intervalMinutes?: number;
+    allowedScenarioKeys: string[];
+    revision: number;
+    updatedAt: string;
+};
+export declare function getConnectorSyncPolicy(connectionId: string): ConnectorSyncPolicy | undefined;
+export declare function listConnectorSyncPolicies(): ConnectorSyncPolicy[];
+export declare function upsertConnectorSyncPolicy(input: {
+    connectionId: string;
+    scanEnabled?: boolean;
+    proactiveEnabled?: boolean;
+    intervalMinutes?: number | null;
+    defaultIntervalMinutes?: number;
+    allowedScenarioKeys?: string[];
+    nowMs?: number;
+}): ConnectorSyncPolicy;

package/dist/src/storage/sqlite/connector-sync-policy-repository.js

@@ -0,0 +1,50 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+//#region src/storage/sqlite/connector-sync-policy-repository.ts
+function stringArray(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function fromRow(row) {
+	return {
+		connectionId: row.connection_id,
+		scanEnabled: row.scan_enabled === 1,
+		proactiveEnabled: row.proactive_enabled === 1,
+		...row.interval_minutes == null ? {} : { intervalMinutes: row.interval_minutes },
+		allowedScenarioKeys: stringArray(row.allowed_scenario_keys_json),
+		revision: row.revision,
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function getConnectorSyncPolicy(connectionId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM connector_sync_policies WHERE connection_id = ?").get(connectionId);
+	return row ? fromRow(row) : void 0;
+}
+function listConnectorSyncPolicies() {
+	return getSqliteDatabase().prepare("SELECT * FROM connector_sync_policies ORDER BY connection_id ASC").all().map(fromRow);
+}
+function upsertConnectorSyncPolicy(input) {
+	const current = getConnectorSyncPolicy(input.connectionId);
+	const now = input.nowMs ?? Date.now();
+	const intervalMinutes = input.intervalMinutes === null ? null : Math.max(5, Math.min(1440, input.intervalMinutes ?? current?.intervalMinutes ?? input.defaultIntervalMinutes ?? 30));
+	const allowedScenarioKeys = [...new Set((input.allowedScenarioKeys ?? current?.allowedScenarioKeys ?? []).map((key) => key.trim()).filter(Boolean))].sort();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO connector_sync_policies (
+        connection_id, scan_enabled, proactive_enabled, interval_minutes,
+        allowed_scenario_keys_json, revision, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 1, ?)
+      ON CONFLICT(connection_id) DO UPDATE SET
+        scan_enabled = excluded.scan_enabled,
+        proactive_enabled = excluded.proactive_enabled,
+        interval_minutes = excluded.interval_minutes,
+        allowed_scenario_keys_json = excluded.allowed_scenario_keys_json,
+        revision = connector_sync_policies.revision + 1,
+        updated_at = excluded.updated_at`).run(input.connectionId, input.scanEnabled ?? current?.scanEnabled ?? true ? 1 : 0, input.proactiveEnabled ?? current?.proactiveEnabled ?? false ? 1 : 0, intervalMinutes, JSON.stringify(allowedScenarioKeys), now);
+	});
+	return getConnectorSyncPolicy(input.connectionId);
+}
+//#endregion
+export { getConnectorSyncPolicy, listConnectorSyncPolicies, upsertConnectorSyncPolicy };

package/dist/src/storage/sqlite/execution-receipt-repository.d.ts

@@ -0,0 +1,146 @@
+import { type ExecutionFailureCode, type ExecutionFailurePhase, type ExecutionRecoveryAction, type ExecutionVerification } from '../../agent/outcomes/execution-verifier.js';
+export type ExecutionReceiptStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type ExecutionFeedbackOutcome = 'helpful' | 'not_helpful';
+export type ExecutionVerdict = 'achieved' | 'partial' | 'not_achieved';
+export type ExecutionReceiptOrigin = 'chat' | 'goal' | 'workflow' | 'automation' | 'browser' | 'proactive';
+export type ExecutionReceiptTrigger = 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
+export interface ExecutionReceiptContext {
+    outcomeId?: string;
+    projectId?: string;
+    goalId?: string;
+    workItemId?: string;
+    origin?: ExecutionReceiptOrigin;
+    triggerKind?: ExecutionReceiptTrigger;
+    parentRunId?: string;
+    contextTraceId?: string;
+}
+export interface ExecutionContract {
+    objective: string;
+    deliverables: string[];
+    acceptanceCriteria: string[];
+    constraints: string[];
+    approvalRequired: string[];
+}
+export interface ExecutionEvidence {
+    kind: 'artifact' | 'test' | 'state' | 'source';
+    title: string;
+    summary: string;
+    uri?: string;
+    verifies?: string[];
+}
+export interface ExecutionReceipt {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    objective: string;
+    status: ExecutionReceiptStatus;
+    summary?: string;
+    contract?: ExecutionContract;
+    contractVersion?: number;
+    attempt: number;
+    strategy?: string;
+    evidence: ExecutionEvidence[];
+    verification: ExecutionVerification;
+    context: ExecutionReceiptContext;
+    nextAction?: string;
+    needsUser: boolean;
+    completionVerdict?: ExecutionVerdict;
+    completionVerdictSource?: 'system' | 'user';
+    correctionText?: string;
+    projectionVersion: number;
+    projectedAt?: number;
+    failure?: {
+        code: ExecutionFailureCode;
+        phase: ExecutionFailurePhase;
+        recoveryAction: ExecutionRecoveryAction;
+    };
+    feedback?: {
+        outcome: ExecutionFeedbackOutcome;
+        reason?: string;
+        needsCorrection?: boolean;
+        supportFit?: boolean;
+    };
+    startedAt: number;
+    completedAt?: number;
+    updatedAt: number;
+}
+export interface ExecutionReceiptMetrics {
+    total: number;
+    completed: number;
+    succeeded: number;
+    verified: number;
+    helpful: number;
+    notHelpful: number;
+    completionRate: number;
+    successRate: number;
+    verificationRate: number;
+    helpfulRate: number;
+}
+export declare function startExecutionReceipt(input: {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    objective: string;
+    context?: ExecutionReceiptContext;
+    contract?: ExecutionContract;
+    contractVersion?: number;
+    attempt?: number;
+    strategy?: string;
+    now?: number;
+}): ExecutionReceipt;
+export declare function completeExecutionReceipt(input: {
+    runId: string;
+    status: Exclude<ExecutionReceiptStatus, 'running'>;
+    summary: string;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function setExecutionVerdict(input: {
+    runId: string;
+    verdict: ExecutionVerdict;
+    correctionText?: string;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function markExecutionReceiptProjected(input: {
+    runId: string;
+    projectionVersion: number;
+    now?: number;
+}): ExecutionReceipt | undefined;
+export declare function listUnprojectedExecutionReceipts(input: {
+    projectionVersion: number;
+    limit?: number;
+}): ExecutionReceipt[];
+export declare function updateExecutionReceipt(input: {
+    runId: string;
+    contract?: ExecutionContract;
+    evidence?: ExecutionEvidence[];
+    summary?: string;
+    nextAction?: string | null;
+    needsUser?: boolean;
+    contextTraceId?: string | null;
+    now?: number;
+}): ExecutionReceipt | undefined;
+type ExecutionReceiptFeedbackInput = {
+    outcome: ExecutionFeedbackOutcome;
+    reason?: string;
+    needsCorrection?: boolean;
+    supportFit?: boolean;
+    now?: number;
+};
+export declare function setExecutionReceiptFeedback(input: ExecutionReceiptFeedbackInput & {
+    sessionKey: string;
+    assistantTimestamp: number;
+}): ExecutionReceipt | undefined;
+export declare function setExecutionReceiptFeedbackByRunId(input: ExecutionReceiptFeedbackInput & {
+    runId: string;
+}): ExecutionReceipt | undefined;
+export declare function getExecutionReceipt(runId: string): ExecutionReceipt | undefined;
+export declare function findExecutionReceiptForAssistant(sessionKey: string, assistantTimestamp: number): ExecutionReceipt | undefined;
+export declare function listExecutionReceipts(input?: {
+    outcomeId?: string;
+    sessionKey?: string;
+    projectId?: string;
+    workItemId?: string;
+    limit?: number;
+}): ExecutionReceipt[];
+export declare function summarizeExecutionReceipts(): ExecutionReceiptMetrics;
+export {};