@tomflow/proflow-platform-host 0.1.30 → 0.1.32

package/dist/src/product-discussion-admission.js

@@ -0,0 +1,191 @@
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+const productRoleRef = /^g-[A-Za-z0-9_-]+$/;
+const bootstrapPrefix = "product-discussion-bootstrap:";
+const tokenBytes = 32;
+const bootstrapRefBytes = 16;
+function requiredText(value, code) {
+    if (value.trim().length === 0)
+        throw new Error(code);
+    return value;
+}
+function positiveInteger(value, code) {
+    if (!Number.isInteger(value) || value <= 0)
+        throw new Error(code);
+    return value;
+}
+function randomBuffer(random, size) {
+    const bytes = Buffer.from(random(size));
+    if (bytes.byteLength !== size)
+        throw new Error("PRODUCT_DISCUSSION_ADMISSION_RANDOM_SOURCE_INVALID");
+    return bytes;
+}
+function secretEqual(left, right) {
+    const a = Buffer.from(left);
+    const b = Buffer.from(right);
+    return a.byteLength === b.byteLength && timingSafeEqual(a, b);
+}
+export function parseProductDiscussionConversationLocator(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.protocol !== "https:" ||
+        parsed.hostname !== "chatgpt.com" ||
+        parsed.username !== "" ||
+        parsed.password !== "" ||
+        parsed.search !== "" ||
+        parsed.hash !== "")
+        return null;
+    const match = /^\/g\/(g-[A-Za-z0-9_-]+)\/c\/([^/]+)$/.exec(parsed.pathname);
+    if (!match?.[1] || !match[2] || !productRoleRef.test(match[1]))
+        return null;
+    return Object.freeze({
+        roleRef: match[1],
+        conversationRef: match[2],
+        conversationLocator: parsed.href,
+    });
+}
+export function productDiscussionRef(identity) {
+    return `product-discussion:${createHash("sha256")
+        .update(JSON.stringify([
+        identity.roleRef,
+        identity.conversationRef,
+        identity.conversationLocator,
+    ]))
+        .digest("hex")}`;
+}
+export function createProductDiscussionAdmissionAuthority(options = {}) {
+    const random = options.randomBytesImpl ?? randomBytes;
+    const admissions = new Map();
+    const expiresAt = new Map();
+    const now = options.now ?? Date.now;
+    const ttlMs = 30 * 60_000;
+    const mint = (input) => Object.freeze({
+        discussionRef: input.discussionRef,
+        roleRef: input.identity.roleRef,
+        conversationRef: input.identity.conversationRef,
+        conversationLocator: input.identity.conversationLocator,
+        generation: input.generation,
+        contentInstanceId: input.contentInstanceId,
+        bootstrapRef: `${bootstrapPrefix}${randomBuffer(random, bootstrapRefBytes).toString("hex")}`,
+        discussionAdmissionToken: randomBuffer(random, tokenBytes).toString("base64url"),
+    });
+    const ensure = (input) => {
+        const discussionRef = requiredText(input.discussionRef, "PRODUCT_DISCUSSION_REF_REQUIRED");
+        const contentInstanceId = requiredText(input.contentInstanceId, "PRODUCT_DISCUSSION_CONTENT_INSTANCE_REQUIRED");
+        const generation = positiveInteger(input.generation, "PRODUCT_DISCUSSION_GENERATION_REQUIRED");
+        const identity = parseProductDiscussionConversationLocator(input.conversationLocator);
+        if (!identity ||
+            identity.roleRef !== input.roleRef ||
+            identity.conversationRef !== input.conversationRef)
+            throw new Error("PRODUCT_DISCUSSION_ADMISSION_IDENTITY_MISMATCH");
+        const current = admissions.get(discussionRef);
+        if (current) {
+            if (current.roleRef !== identity.roleRef ||
+                current.conversationRef !== identity.conversationRef ||
+                current.conversationLocator !== identity.conversationLocator)
+                throw new Error("PRODUCT_DISCUSSION_ADMISSION_IDENTITY_MISMATCH");
+            if (generation < current.generation)
+                throw new Error("PRODUCT_DISCUSSION_ADMISSION_GENERATION_STALE");
+            if (generation === current.generation &&
+                current.contentInstanceId === contentInstanceId &&
+                (expiresAt.get(discussionRef) ?? 0) > now())
+                return current;
+        }
+        const admission = mint({
+            discussionRef,
+            identity,
+            generation,
+            contentInstanceId,
+        });
+        admissions.set(discussionRef, admission);
+        expiresAt.set(discussionRef, now() + ttlMs);
+        return admission;
+    };
+    const verify = (input) => {
+        const current = admissions.get(input.discussionRef);
+        return Boolean(current &&
+            (expiresAt.get(input.discussionRef) ?? 0) > now() &&
+            current.roleRef === input.roleRef &&
+            current.conversationRef === input.conversationRef &&
+            current.conversationLocator === input.conversationLocator &&
+            current.generation === input.generation &&
+            secretEqual(current.discussionAdmissionToken, input.discussionAdmissionToken));
+    };
+    return Object.freeze({
+        ensure,
+        verify,
+        get(discussionRef) {
+            return admissions.get(discussionRef);
+        },
+        revoke(discussionRef) {
+            expiresAt.delete(discussionRef);
+            return admissions.delete(discussionRef);
+        },
+        clear() {
+            admissions.clear();
+            expiresAt.clear();
+        },
+    });
+}
+export async function assertProductDiscussionConversationPreTask(options) {
+    const taskIds = await options.listTaskIds();
+    for (const taskId of taskIds) {
+        const bindings = await options.getTaskRoleBindings(taskId);
+        if (bindings.some((binding) => binding.conversationLocator === options.conversationLocator))
+            throw new Error("PRODUCT_DISCUSSION_TASK_WORKER_FORBIDDEN");
+    }
+}
+export function createProductDiscussionAdmissionCoordinator(options) {
+    if (!productRoleRef.test(options.productRoleRef))
+        throw new Error("PRODUCT_DISCUSSION_ROLE_INVALID");
+    const observe = async (input) => {
+        const contentInstanceId = requiredText(input.contentInstanceId, "PRODUCT_DISCUSSION_CONTENT_INSTANCE_REQUIRED");
+        const identity = parseProductDiscussionConversationLocator(input.conversationLocator);
+        if (!identity)
+            return Object.freeze({
+                admitted: false,
+                reason: "NOT_CUSTOM_GPT_CONVERSATION",
+            });
+        if (identity.roleRef !== options.productRoleRef)
+            return Object.freeze({
+                admitted: false,
+                reason: "NOT_PRODUCT_ROLE",
+            });
+        if (options.isTaskWorkerProvisioning(identity.roleRef))
+            throw new Error("PRODUCT_DISCUSSION_TASK_WORKER_PROVISIONING");
+        await assertProductDiscussionConversationPreTask({
+            conversationLocator: identity.conversationLocator,
+            listTaskIds: options.listTaskIds,
+            getTaskRoleBindings: options.getTaskRoleBindings,
+        });
+        const discussionRef = productDiscussionRef(identity);
+        const session = await options.registerDiscussionSession({
+            discussionRef,
+            ...identity,
+        });
+        if (session.status !== "ACTIVE" ||
+            session.discussionRef !== discussionRef ||
+            session.roleRef !== identity.roleRef ||
+            session.conversationRef !== identity.conversationRef ||
+            session.conversationLocator !== identity.conversationLocator)
+            throw new Error("PRODUCT_DISCUSSION_SESSION_IDENTITY_MISMATCH");
+        const admission = options.authority.ensure({
+            discussionRef,
+            ...identity,
+            generation: session.generation,
+            contentInstanceId,
+        });
+        await options.deliverBootstrap(admission);
+        return Object.freeze({
+            admitted: true,
+            discussionRef,
+            discussionGeneration: session.generation,
+            bootstrapRef: admission.bootstrapRef,
+        });
+    };
+    return Object.freeze({ observe });
+}

package/dist/src/product-discussion-host.d.ts

@@ -0,0 +1,43 @@
+import type { ExecuteCapabilityRequest } from "@tomflow/proflow-execution-contracts";
+import { type ProductDiscussionAdmissionVerification, type ProductDiscussionSessionOwnerFact, type ProductDiscussionTaskRoleBindingFact } from "./product-discussion-admission.ts";
+export type ProductDiscussionHostTaskFact = Readonly<{
+    taskId: string;
+    status: string;
+    roleBindings: readonly ProductDiscussionTaskRoleBindingFact[];
+}>;
+export declare function createProductDiscussionHost(options: {
+    productRoleRef: string;
+    listTaskIds(): readonly string[] | Promise<readonly string[]>;
+    getTaskFact(taskId: string): ProductDiscussionHostTaskFact | Promise<ProductDiscussionHostTaskFact>;
+    registerDiscussionSession(input: {
+        discussionRef: string;
+        roleRef: string;
+        conversationRef: string;
+        conversationLocator: string;
+    }): ProductDiscussionSessionOwnerFact | Promise<ProductDiscussionSessionOwnerFact>;
+    getDiscussionSession(discussionRef: string): ProductDiscussionSessionOwnerFact | Promise<ProductDiscussionSessionOwnerFact>;
+    executeCapability(request: ExecuteCapabilityRequest): Promise<unknown>;
+}): Readonly<{
+    recoverReservations: () => Promise<void>;
+    reserveTaskWorker: (taskId: string, roleRef: string) => void;
+    releaseTaskWorker: (taskId: string, roleRef: string) => void;
+    isTaskWorkerProvisioning: (roleRef: string) => boolean;
+    observe: (input: {
+        conversationLocator: string;
+        contentInstanceId: string;
+    }) => Promise<Readonly<{
+        admitted: false;
+        reason: "NOT_CUSTOM_GPT_CONVERSATION";
+    }> | Readonly<{
+        admitted: false;
+        reason: "NOT_PRODUCT_ROLE";
+    }> | Readonly<{
+        admitted: true;
+        discussionRef: string;
+        discussionGeneration: number;
+        bootstrapRef: string;
+    }>>;
+    authorizeBootstrapExecution: (request: ExecuteCapabilityRequest) => Promise<boolean>;
+    verifyAdmission(input: ProductDiscussionAdmissionVerification): boolean;
+    clear(): void;
+}>;

package/dist/src/product-discussion-host.js

@@ -0,0 +1,167 @@
+import { assertProductDiscussionConversationPreTask, createProductDiscussionAdmissionAuthority, createProductDiscussionAdmissionCoordinator, parseProductDiscussionConversationLocator, productDiscussionRef, } from "./product-discussion-admission.js";
+const reservableTaskStatuses = new Set(["PENDING", "READY", "ACTIVE", "WAITING"]);
+function object(value, code) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error(code);
+    return value;
+}
+export function createProductDiscussionHost(options) {
+    const authority = createProductDiscussionAdmissionAuthority();
+    const provisioning = new Map();
+    let recovered = false;
+    const reserveTaskWorker = (taskId, roleRef) => {
+        if (roleRef !== options.productRoleRef)
+            return;
+        const current = provisioning.get(roleRef) ?? new Set();
+        current.add(taskId);
+        provisioning.set(roleRef, current);
+    };
+    const releaseTaskWorker = (taskId, roleRef) => {
+        if (roleRef !== options.productRoleRef)
+            return;
+        const current = provisioning.get(roleRef);
+        if (!current)
+            return;
+        current.delete(taskId);
+        if (current.size === 0)
+            provisioning.delete(roleRef);
+    };
+    const isTaskWorkerProvisioning = (roleRef) => roleRef === options.productRoleRef &&
+        (!recovered || (provisioning.get(roleRef)?.size ?? 0) > 0);
+    const coordinator = createProductDiscussionAdmissionCoordinator({
+        productRoleRef: options.productRoleRef,
+        authority,
+        isTaskWorkerProvisioning,
+        listTaskIds: options.listTaskIds,
+        async getTaskRoleBindings(taskId) {
+            return (await options.getTaskFact(taskId)).roleBindings;
+        },
+        registerDiscussionSession: options.registerDiscussionSession,
+        async deliverBootstrap(admission) {
+            const request = {
+                contract: "execution",
+                contractVersion: "1.0.0",
+                idempotencyKey: admission.bootstrapRef,
+                callerRef: "platform-host:product-discussion-admission",
+                correlationId: admission.bootstrapRef,
+                roleRef: admission.roleRef,
+                capability: "product.discussion.bootstrap.deliver",
+                input: {
+                    bootstrapRef: admission.bootstrapRef,
+                    discussionRef: admission.discussionRef,
+                    discussionGeneration: admission.generation,
+                    discussionAdmissionToken: admission.discussionAdmissionToken,
+                    roleRef: admission.roleRef,
+                    conversationRef: admission.conversationRef,
+                    conversationLocator: admission.conversationLocator,
+                    contentInstanceId: admission.contentInstanceId,
+                    contentFingerprint: admission.bootstrapRef,
+                },
+            };
+            const execution = object(await options.executeCapability(request), "PRODUCT_DISCUSSION_BOOTSTRAP_EXECUTION_INVALID");
+            const result = execution.result === undefined
+                ? undefined
+                : object(execution.result, "PRODUCT_DISCUSSION_BOOTSTRAP_RESULT_INVALID");
+            const data = result?.data === undefined
+                ? undefined
+                : object(result.data, "PRODUCT_DISCUSSION_BOOTSTRAP_RESULT_DATA_INVALID");
+            if (execution.status !== "SUCCEEDED" ||
+                execution.sideEffectState !== "APPLIED" ||
+                result?.capability !== "product.discussion.bootstrap.deliver" ||
+                data?.bootstrapRef !== admission.bootstrapRef ||
+                data?.delivered !== true ||
+                typeof data.evidenceRef !== "string")
+                throw new Error(`PRODUCT_DISCUSSION_BOOTSTRAP_NOT_CONFIRMED:${String(execution.status)}:${String(execution.sideEffectState)}`);
+        },
+    });
+    const recoverReservations = async () => {
+        if (recovered)
+            return;
+        const taskIds = await options.listTaskIds();
+        for (const taskId of taskIds) {
+            const task = await options.getTaskFact(taskId);
+            if (!reservableTaskStatuses.has(task.status))
+                continue;
+            for (const binding of task.roleBindings)
+                if (binding.roleRef === options.productRoleRef &&
+                    (!binding.workerRef || !binding.conversationLocator))
+                    reserveTaskWorker(task.taskId, binding.roleRef);
+        }
+        recovered = true;
+    };
+    const authorizeBootstrapExecution = async (request) => {
+        if (request.capability !== "product.discussion.bootstrap.deliver")
+            return false;
+        try {
+            if (!recovered)
+                return false;
+            if (request.callerRef !== "platform-host:product-discussion-admission")
+                return false;
+            if (request.taskId !== undefined ||
+                request.nodeId !== undefined ||
+                request.runNo !== undefined ||
+                request.workerRef !== undefined ||
+                request.projectRoot !== undefined)
+                return false;
+            const input = request.input;
+            if (request.roleRef !== options.productRoleRef ||
+                input.roleRef !== options.productRoleRef ||
+                isTaskWorkerProvisioning(input.roleRef) ||
+                input.contentFingerprint !== input.bootstrapRef)
+                return false;
+            const identity = parseProductDiscussionConversationLocator(input.conversationLocator);
+            if (!identity ||
+                identity.roleRef !== input.roleRef ||
+                identity.conversationRef !== input.conversationRef ||
+                productDiscussionRef(identity) !== input.discussionRef)
+                return false;
+            await assertProductDiscussionConversationPreTask({
+                conversationLocator: input.conversationLocator,
+                listTaskIds: options.listTaskIds,
+                async getTaskRoleBindings(taskId) {
+                    return (await options.getTaskFact(taskId)).roleBindings;
+                },
+            });
+            const session = await options.getDiscussionSession(input.discussionRef);
+            if (session.status !== "ACTIVE" ||
+                session.discussionRef !== input.discussionRef ||
+                session.roleRef !== input.roleRef ||
+                session.conversationRef !== input.conversationRef ||
+                session.conversationLocator !== input.conversationLocator ||
+                session.generation !== input.discussionGeneration)
+                return false;
+            const current = authority.get(input.discussionRef);
+            if (!current ||
+                current.bootstrapRef !== input.bootstrapRef ||
+                current.contentInstanceId !== input.contentInstanceId)
+                return false;
+            return authority.verify({
+                discussionRef: input.discussionRef,
+                roleRef: input.roleRef,
+                conversationRef: input.conversationRef,
+                conversationLocator: input.conversationLocator,
+                generation: input.discussionGeneration,
+                discussionAdmissionToken: input.discussionAdmissionToken,
+            });
+        }
+        catch {
+            return false;
+        }
+    };
+    return Object.freeze({
+        recoverReservations,
+        reserveTaskWorker,
+        releaseTaskWorker,
+        isTaskWorkerProvisioning,
+        observe: coordinator.observe,
+        authorizeBootstrapExecution,
+        verifyAdmission(input) {
+            return recovered && !isTaskWorkerProvisioning(input.roleRef) && authority.verify(input);
+        },
+        clear() {
+            authority.clear();
+            provisioning.clear();
+            recovered = false;
+        },
+    });
+}

package/dist/src/reconciliation-coordinator.d.ts

@@ -33,5 +33,6 @@ export declare function createReconciliationCoordinator(options: ReconciliationC
     kick(taskId: string, signal?: TaskResumeSignal): void;
     reconcile: (taskId: string, signal?: TaskResumeSignal) => Promise<void>;
     sweep: () => Promise<void>;
+    drain(): Promise<void>;
     stop(): void;
 }>;

package/dist/src/reconciliation-coordinator.js

@@ -197,8 +197,7 @@ export function createReconciliationCoordinator(options) {
             }
         })().finally(() => {
             taskInFlight.delete(taskId);
-            if (!stopped &&
-                (pendingSignals.has(taskId) || failures.has(taskId)))
+            if (!stopped && (pendingSignals.has(taskId) || failures.has(taskId)))
                 schedulePendingRetry(taskId);
             else
                 admittedTasks.delete(taskId);
@@ -318,6 +317,12 @@ export function createReconciliationCoordinator(options) {
         },
         reconcile,
         sweep,
+        async drain() {
+            await Promise.allSettled([
+                ...(sweepInFlight ? [sweepInFlight] : []),
+                ...taskInFlight.values(),
+            ]);
+        },
         stop() {
             if (stopped)
                 return;

package/dist/src/role-operations.js

@@ -42,6 +42,14 @@ export const roleOperations = {
         "getTask",
         "putTaskDocument",
         "getTaskDocument",
+        "getProductCampaign",
+        "getProductDiscussionContext",
+        "getProductDocument",
+        "putProductDocument",
+        "getCampaignAuthorization",
+        "submitProductTaskIntent",
+        "recordProductGapReview",
+        "recordProductGoalSatisfied",
         "askPeer",
         "replyPeer",
         ...directToolActionIds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-host",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,19 +24,19 @@
   ],
   "dependencies": {
     "zod": "4.1.12",
-    "@tomflow/proflow-execution-browser-extension": "^0.1.62",
-    "@tomflow/proflow-task-migration-runner": "^0.1.11",
-    "@tomflow/proflow-task-orchestration": "^0.1.11",
-    "@tomflow/proflow-task-store-sqlite": "^0.1.12",
-    "@tomflow/proflow-agent-runtime": "^0.1.17",
+    "@tomflow/proflow-agent-runtime": "^0.1.18",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-contracts": "^0.1.11"
+    "@tomflow/proflow-task-migration-runner": "^0.1.11",
+    "@tomflow/proflow-execution-browser-extension": "^0.1.74",
+    "@tomflow/proflow-execution-contracts": "^0.1.12",
+    "@tomflow/proflow-task-orchestration": "^0.1.12",
+    "@tomflow/proflow-task-store-sqlite": "^0.1.12"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.13",
-    "@tomflow/proflow-execution-runtime": "^0.1.19",
-    "@tomflow/proflow-model-runtime": "^0.1.25",
-    "@tomflow/proflow-agent-gateway": "^0.1.18"
+    "@tomflow/proflow-agent-gateway": "^0.1.19",
+    "@tomflow/proflow-execution-runtime": "^0.1.20",
+    "@tomflow/proflow-model-runtime": "^0.1.26",
+    "@tomflow/proflow-deployment-conformance": "^0.1.13"
   },
   "description": "Provides the ProFlow local application composition root that binds Task, Agent, Execution and Model owner transports.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-host",
 	"packageName": "@tomflow/proflow-platform-host",
-	"moduleVersion": "0.1.30",
+	"moduleVersion": "0.1.32",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",