@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/server/routes/tasks.js

@@ -58,6 +58,7 @@ import { parseJsonBody } from '../routes.js';
 import { resolveErrorStatusCode, requestHeader, requestRuntimeMode } from './shared.js';
 import { listBuiltInCustomTaxonomyLibraryPacks } from '../../shared/customTaxonomyLibrary.js';
 import { listBuiltInTaxonomyLibraryPacks } from '../../shared/taxonomyLibrary.js';
+import { shouldUseProvisionalTaskReferences } from '../../utils/taskReferences.js';
 // === SECTION: Registration ===
 export function registerTaskRoutes(deps) {
     const { addRoute, core, context, requestWorkspaceId, ensureAppAccess, resolveEffectiveObjectStorageConfig, buildBatchSummary, CLOUD_SAFE_CONFIG_PATHS, } = deps;
@@ -343,7 +344,8 @@ export function registerTaskRoutes(deps) {
             const result = core.bulkCreateTasks([taskInput], {
                 atomic: true,
                 validateOnly: true,
-                workspaceId
+                workspaceId,
+                provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
             });
             const hasErrors = result.errors.length > 0;
             const failureStatus = hasErrors
@@ -361,7 +363,11 @@ export function registerTaskRoutes(deps) {
         }
         try {
             const workspaceId = requestWorkspaceId(req);
-            const task = core.createTask(taskInput, { workspaceId, actorRef: 'user' });
+            const task = core.createTask(taskInput, {
+                workspaceId,
+                actorRef: 'user',
+                provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
+            });
             res.writeHead(201, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(task));
         }
@@ -386,7 +392,14 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const updated = core.updateTask(params.id, body, workspaceId, { actorRef: 'user' });
+            const saveSource = body?.saveSource === 'autosave' ? 'autosave' : 'manual';
+            const updates = body && typeof body === 'object'
+                ? Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'saveSource'))
+                : body;
+            const updated = core.updateTask(params.id, updates, workspaceId, {
+                actorRef: 'user',
+                skipTaskEvents: saveSource === 'autosave'
+            });
             if (!updated) {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Task not found' }));
@@ -869,7 +882,8 @@ export function registerTaskRoutes(deps) {
         const result = core.bulkCreateTasks(tasks, {
             atomic: atomic !== false,
             validateOnly: validate_only === true,
-            workspaceId
+            workspaceId,
+            provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
         });
         const hasErrors = result.errors.length > 0;
         const succeeded = validate_only ? (hasErrors ? 0 : result.total) : result.created.length;

package/dist/server/routes.js

@@ -10,6 +10,7 @@ import { createHash, randomUUID } from 'crypto';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { TaskforceRuleError } from '../core/Taskforce.js';
+import { parseAiProfileBootstrapHeaders } from '../mcp/aiProfileBootstrap.js';
 import { createTaskforceMcpServer, isMcpWriteToolName } from '../mcp/runtime.js';
 import { applyPrefixedRateLimitHeaders } from './rateLimit.js';
 import { createSessionTokenCookie, resolveRequestAccess } from './auth.js';
@@ -69,6 +70,20 @@ function readPositiveInteger(value, fallback) {
         return fallback;
     return parsed;
 }
+function resolveBooleanSetting(value, fallback) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized)
+        return fallback;
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return fallback;
+}
 // Convert route pattern like '/api/taskforce/tasks/:id' to regex
 function createRoutePattern(path) {
     const keys = [];
@@ -330,20 +345,20 @@ export function createRoutes(core, context = {}) {
         const authSettings = globalSettings.auth || {};
         const authRateLimitMaxRequestsRaw = Number(authSettings.authRateLimitMaxRequests);
         const authRateLimitWindowMsRaw = Number(authSettings.authRateLimitWindowMs);
-        const signupSettings = core.getSignupMonetizationSettings();
+        const onboardingPolicy = core.getOnboardingPolicy();
         return {
-            allowSelfRegistration: authSettings.allowSelfRegistration !== false,
-            requireVerifiedEmail: authSettings.requireVerifiedEmail !== false,
-            defaultNewUserBetaAccess: authSettings.defaultNewUserBetaAccess === true,
-            authRateLimitEnabled: authSettings.authRateLimitEnabled !== false,
+            allowSelfRegistration: resolveBooleanSetting(authSettings.allowSelfRegistration, true),
+            requireVerifiedEmail: resolveBooleanSetting(authSettings.requireVerifiedEmail, true),
+            defaultNewUserBetaAccess: resolveBooleanSetting(authSettings.defaultNewUserBetaAccess, false),
+            authRateLimitEnabled: resolveBooleanSetting(authSettings.authRateLimitEnabled, true),
             authRateLimitMaxRequests: Number.isFinite(authRateLimitMaxRequestsRaw) && authRateLimitMaxRequestsRaw >= 1
                 ? Math.floor(authRateLimitMaxRequestsRaw)
                 : 10,
             authRateLimitWindowMs: Number.isFinite(authRateLimitWindowMsRaw) && authRateLimitWindowMsRaw >= 1000
                 ? Math.floor(authRateLimitWindowMsRaw)
                 : 15 * 60_000,
-            signupMonetizationStrategy: signupSettings.strategy,
-            defaultSignupPlanVersionId: signupSettings.defaultSignupPlanVersionId
+            onboardingPolicyMode: onboardingPolicy.mode,
+            onboardingPlanVersionId: onboardingPolicy.planVersionId
         };
     };
     const deliverAuthEmail = async (kind, email, token, req) => {
@@ -1124,13 +1139,7 @@ export function createRoutes(core, context = {}) {
             ? authorization.slice(7).trim()
             : '';
         const requestedWorkspaceId = requestHeader(req, 'x-taskforce-workspace-id', '').trim();
-        const aiProfileToken = requestHeader(req, 'x-taskforce-ai-profile-token', '').trim() || null;
-        const aiProfileName = requestHeader(req, 'x-taskforce-ai-name', '').trim() || null;
-        const aiProfileDescription = requestHeader(req, 'x-taskforce-ai-description', '').trim() || null;
-        const aiProfileRole = requestHeader(req, 'x-taskforce-ai-role', '').trim() || null;
-        const aiProfileProvider = requestHeader(req, 'x-taskforce-ai-provider', '').trim() || null;
-        const aiProfileModel = requestHeader(req, 'x-taskforce-ai-model', '').trim() || null;
-        const aiProfileSurfaceType = requestHeader(req, 'x-taskforce-ai-surface-type', '').trim() || null;
+        const bootstrap = parseAiProfileBootstrapHeaders(req.headers);
         if (bearerToken) {
             const tokenAuth = core.authenticateMcpAccessToken(bearerToken);
             const oauthAuth = tokenAuth ? null : core.authenticateMcpOAuthAccessToken(bearerToken);
@@ -1178,13 +1187,7 @@ export function createRoutes(core, context = {}) {
                 authenticatedViaToken: tokenAuth || null,
                 authenticatedViaOAuth: oauthAuth || null,
                 userId: null,
-                aiProfileToken,
-                aiProfileName,
-                aiProfileDescription,
-                aiProfileRole,
-                aiProfileProvider,
-                aiProfileModel,
-                aiProfileSurfaceType,
+                ...bootstrap,
             };
         }
         core.addMcpAuditLog({
@@ -1461,6 +1464,8 @@ export function createRoutes(core, context = {}) {
                     tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
                     aiProfileToken: auth.aiProfileToken,
                     aiProfileName: auth.aiProfileName,
+                    aiProfileIcon: auth.aiProfileIcon,
+                    aiProfileColor: auth.aiProfileColor,
                     aiProfileDescription: auth.aiProfileDescription,
                     aiProfileRole: auth.aiProfileRole,
                     aiProfileProvider: auth.aiProfileProvider,
@@ -1495,7 +1500,7 @@ export function createRoutes(core, context = {}) {
     };
     const resolveAdminRequestActor = makeResolveAdminRequestActor(core, context);
     const auditAdminAction = makeAuditAdminAction(core, context);
-    const auditAuthAction = makeAuditAuthAction(core, requestWorkspaceId);
+    const auditAuthAction = makeAuditAuthAction(core, requestWorkspaceId, context);
     const ensureAdminRole = makeEnsureAdminRole(core, context);
     const ensureAuthenticatedUser = makeEnsureAuthenticatedUser();
     const isCollaborationPolicyEnabled = () => {
@@ -1560,6 +1565,8 @@ export function createRoutes(core, context = {}) {
         shouldExposeDevAuthTokens,
         resolveRuntimeConfigBaseUrl,
         resolvePublicAuthBaseUrl,
+        resolveEffectiveObjectStorageConfig,
+        getObjectStorageClient,
     });
     registerWorkspaceRoutes({
         addRoute,