@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/storage/objectStorageConfig.js

@@ -26,7 +26,9 @@ export function resolveObjectStorageConfigFromEnv(env = process.env) {
     const accessKeyId = readRequired(env, 'R2_ACCESS_KEY_ID');
     const secretAccessKey = readRequired(env, 'R2_SECRET_ACCESS_KEY');
     const endpoint = String(env.R2_ENDPOINT || '').trim() || `https://${accountId}.r2.cloudflarestorage.com`;
-    const keyPrefix = String(env.R2_KEY_PREFIX || 'taskforce').trim() || 'taskforce';
+    const keyPrefix = typeof env.R2_KEY_PREFIX === 'string'
+        ? env.R2_KEY_PREFIX.trim().replace(/^\/+|\/+$/g, '')
+        : '';
     const signedUploadTtlSeconds = readPositiveInteger(env.R2_SIGNED_UPLOAD_TTL_SECONDS, 600);
     const signedDownloadTtlSeconds = readPositiveInteger(env.R2_SIGNED_DOWNLOAD_TTL_SECONDS, 300);
     return {

package/dist/storage/objectStorageConfig.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/objectStorageConfig.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { resolveObjectStorageConfigFromEnv } from './objectStorageConfig.js';
+describe('resolveObjectStorageConfigFromEnv', () => {
+    it('allows an empty R2 key prefix', () => {
+        const config = resolveObjectStorageConfigFromEnv({
+            TASKFORCE_OBJECT_STORAGE_PROVIDER: 'r2',
+            R2_ACCOUNT_ID: 'acct-1',
+            R2_BUCKET: 'taskforce-dev-assets',
+            R2_ACCESS_KEY_ID: 'access-key-1',
+            R2_SECRET_ACCESS_KEY: 'secret-key-1',
+            R2_KEY_PREFIX: ''
+        });
+        expect(config).toEqual({
+            provider: 'r2',
+            r2: {
+                accountId: 'acct-1',
+                bucket: 'taskforce-dev-assets',
+                endpoint: 'https://acct-1.r2.cloudflarestorage.com',
+                accessKeyId: 'access-key-1',
+                secretAccessKey: 'secret-key-1',
+                keyPrefix: '',
+                signedUploadTtlSeconds: 600,
+                signedDownloadTtlSeconds: 300
+            }
+        });
+    });
+    it('trims slashes from a non-empty R2 key prefix', () => {
+        const config = resolveObjectStorageConfigFromEnv({
+            TASKFORCE_OBJECT_STORAGE_PROVIDER: 'r2',
+            R2_ACCOUNT_ID: 'acct-1',
+            R2_BUCKET: 'taskforce-dev-assets',
+            R2_ACCESS_KEY_ID: 'access-key-1',
+            R2_SECRET_ACCESS_KEY: 'secret-key-1',
+            R2_KEY_PREFIX: '/taskforce-assets/'
+        });
+        expect(config.r2?.keyPrefix).toBe('taskforce-assets');
+    });
+});

package/dist/storage/postgresAdapter.d.ts

@@ -1,4 +1,9 @@
 import type { DatabaseAdapter, DatabaseStatement } from './databaseAdapter.js';
+export declare function replaceQMarkParams(sql: string, params: unknown[]): {
+    text: string;
+    values: unknown[];
+};
+export declare function translateInsertOrReplace(sql: string): string;
 export declare class PostgresAdapter implements DatabaseAdapter {
     readonly provider: "postgres";
     readonly open = true;

package/dist/storage/postgresAdapter.js

@@ -9,7 +9,7 @@ const RESPONSE_BUFFER_BYTES = 2 * 1024 * 1024;
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
-function replaceQMarkParams(sql, params) {
+export function replaceQMarkParams(sql, params) {
     let index = 0;
     const text = sql.replace(/\?/g, () => {
         index += 1;
@@ -29,7 +29,7 @@ function replaceNamedParams(sql, params) {
     });
     return { text, values };
 }
-function translateInsertOrReplace(sql) {
+export function translateInsertOrReplace(sql) {
     const match = sql.match(/INSERT\s+OR\s+REPLACE\s+INTO\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([\s\S]*?)\)\s*VALUES\s*\(([\s\S]*?)\)/i);
     if (!match)
         return sql;

package/dist/storage/postgresAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/postgresAdapter.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { replaceQMarkParams, translateInsertOrReplace } from './postgresAdapter.js';
+describe('postgresAdapter', () => {
+    it('preserves ai_profiles sync upserts and only translates placeholders for Postgres', () => {
+        const sql = `
+            INSERT INTO ai_profiles (
+                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
+                provider_metadata_json, created_at, updated_at, last_active_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                workspace_id = excluded.workspace_id,
+                profile_token = excluded.profile_token,
+                name = excluded.name,
+                username = excluded.username,
+                icon = excluded.icon,
+                color = excluded.color,
+                provider_metadata_json = excluded.provider_metadata_json,
+                created_at = excluded.created_at,
+                updated_at = excluded.updated_at,
+                last_active_at = excluded.last_active_at
+        `;
+        const translated = translateInsertOrReplace(sql);
+        expect(translated).toBe(sql);
+        const bound = replaceQMarkParams(translated, ['a', 'b', 'c']);
+        expect(bound.text).toContain('VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)');
+        expect(bound.text).toContain('ON CONFLICT(id) DO UPDATE SET');
+        expect(bound.values).toEqual(['a', 'b', 'c']);
+    });
+});

package/dist/storage/taskAssetStore.d.ts

@@ -1,6 +1,5 @@
 import type { DatabaseAdapter } from './databaseAdapter.js';
 import type { ObjectStorageProvider } from './objectStorage.js';
-import { DocumentRegistry } from './documentRegistry.js';
 import type { VirusScanResult } from '../security/virusScan.js';
 export type TaskAssetQuarantineStatus = 'none' | 'quarantined' | 'released';
 export interface TaskAssetEntry {
@@ -24,9 +23,7 @@ export interface TaskAssetEntry {
 export declare class TaskAssetStore {
     private readonly db;
     private readonly tenantId;
-    private readonly fallbackRegistry;
-    constructor(db: DatabaseAdapter, tenantId: string, basePath: string, fallbackRegistry?: DocumentRegistry);
-    private backfillFromRegistry;
+    constructor(db: DatabaseAdapter, tenantId: string);
     private upsertEntry;
     get(pathValue: string, workspaceIdRaw?: string): TaskAssetEntry | null;
     isDeleted(pathValue: string, workspaceIdRaw?: string): boolean;
@@ -45,6 +42,12 @@ export declare class TaskAssetStore {
     remove(pathValue: string, workspaceIdRaw?: string): boolean;
     listPurgeCandidates(now?: Date): TaskAssetEntry[];
     listAll(limit?: number): TaskAssetEntry[];
+    listWorkspace(workspaceIdRaw?: string, options?: {
+        limit?: number;
+        includeDeleted?: boolean;
+    }): TaskAssetEntry[];
+    upsertSyncEntry(entryInput: TaskAssetEntry): TaskAssetEntry;
+    applySyncDelete(pathValue: string, deletedAt: string, workspaceIdRaw?: string): TaskAssetEntry | null;
     updateQuarantineStatus(pathValue: string, quarantineStatus: TaskAssetQuarantineStatus, workspaceIdRaw?: string): TaskAssetEntry | null;
     updateScanResult(input: {
         path: string;

package/dist/storage/taskAssetStore.js

@@ -1,4 +1,3 @@
-import { DocumentRegistry } from './documentRegistry.js';
 function normalizeLimit(limitRaw, fallback) {
     return Number.isFinite(limitRaw) ? Math.max(1, Math.floor(Number(limitRaw))) : fallback;
 }
@@ -16,24 +15,6 @@ function inferWorkspaceIdFromPath(rawPath) {
         return match[1];
     return 'default';
 }
-function mapRegistryEntry(tenantId, workspaceId, entry) {
-    return {
-        tenantId,
-        workspaceId,
-        path: entry.path,
-        provider: entry.provider,
-        version: entry.version,
-        contentType: entry.contentType,
-        sizeBytes: entry.sizeBytes,
-        sha256: entry.sha256,
-        uploadedAt: entry.uploadedAt,
-        scan: entry.scan,
-        quarantineStatus: entry.scan.verdict === 'infected' ? 'quarantined' : 'none',
-        deletedAt: entry.deletedAt || null,
-        purgeAfter: entry.purgeAfter || null,
-        updatedAt: entry.uploadedAt
-    };
-}
 function mapRow(row) {
     return {
         tenantId: String(row.tenant_id || 'default'),
@@ -60,20 +41,9 @@ function mapRow(row) {
 export class TaskAssetStore {
     db;
     tenantId;
-    fallbackRegistry;
-    constructor(db, tenantId, basePath, fallbackRegistry) {
+    constructor(db, tenantId) {
         this.db = db;
         this.tenantId = tenantId;
-        this.fallbackRegistry = fallbackRegistry || new DocumentRegistry(basePath);
-    }
-    backfillFromRegistry(pathValue) {
-        const fallback = this.fallbackRegistry.get(pathValue);
-        if (!fallback)
-            return null;
-        const workspaceId = inferWorkspaceIdFromPath(fallback.path);
-        const entry = mapRegistryEntry(this.tenantId, workspaceId, fallback);
-        this.upsertEntry(entry);
-        return this.get(entry.path, entry.workspaceId);
     }
     upsertEntry(entry) {
         this.db.prepare(`
@@ -124,7 +94,7 @@ export class TaskAssetStore {
         `).get(this.tenantId, workspaceId, normalizedPath);
         if (row)
             return mapRow(row);
-        return this.backfillFromRegistry(normalizedPath);
+        return null;
     }
     isDeleted(pathValue, workspaceIdRaw) {
         const entry = this.get(pathValue, workspaceIdRaw);
@@ -160,16 +130,6 @@ export class TaskAssetStore {
             updatedAt: nowIso
         };
         this.upsertEntry(entry);
-        // One-release compatibility mirror.
-        this.fallbackRegistry.recordUpload({
-            path: normalizedPath,
-            provider: input.provider,
-            contentType: entry.contentType,
-            sizeBytes: entry.sizeBytes,
-            sha256: entry.sha256,
-            uploadedAt: entry.uploadedAt,
-            scan: input.scan
-        });
         return entry;
     }
     markDeleted(pathValue, retentionDays, workspaceIdRaw) {
@@ -185,7 +145,6 @@ export class TaskAssetStore {
             SET deleted_at = ?, purge_after = ?, updated_at = ?
             WHERE tenant_id = ? AND workspace_id = ? AND path = ?
         `).run(nowIso, purgeAt, nowIso, this.tenantId, entry.workspaceId, entry.path);
-        this.fallbackRegistry.markDeleted(entry.path, safeDays);
         return this.get(entry.path, entry.workspaceId);
     }
     clearDeleted(pathValue, workspaceIdRaw) {
@@ -198,7 +157,6 @@ export class TaskAssetStore {
             SET deleted_at = NULL, purge_after = NULL, updated_at = ?
             WHERE tenant_id = ? AND workspace_id = ? AND path = ?
         `).run(nowIso, this.tenantId, entry.workspaceId, entry.path);
-        this.fallbackRegistry.clearDeleted(entry.path);
         return this.get(entry.path, entry.workspaceId);
     }
     remove(pathValue, workspaceIdRaw) {
@@ -209,7 +167,6 @@ export class TaskAssetStore {
             DELETE FROM task_assets
             WHERE tenant_id = ? AND workspace_id = ? AND path = ?
         `).run(this.tenantId, entry.workspaceId, entry.path);
-        this.fallbackRegistry.remove(entry.path);
         return Number(result?.changes || 0) > 0;
     }
     listPurgeCandidates(now = new Date()) {
@@ -234,22 +191,70 @@ export class TaskAssetStore {
             ORDER BY path ASC
             LIMIT ?
         `).all(this.tenantId, safeLimit);
-        // Opportunistic backfill for compatibility records.
-        for (const legacy of this.fallbackRegistry.listAll()) {
-            const workspaceId = inferWorkspaceIdFromPath(legacy.path);
-            const exists = rows.find((row) => String(row.path || '') === legacy.path && String(row.workspace_id || '') === workspaceId);
-            if (!exists) {
-                this.upsertEntry(mapRegistryEntry(this.tenantId, workspaceId, legacy));
+        return rows.map(mapRow);
+    }
+    listWorkspace(workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const safeLimit = normalizeLimit(options?.limit, 500);
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = includeDeleted
+            ? this.db.prepare(`
+                SELECT *
+                FROM task_assets
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                ORDER BY path ASC
+                LIMIT ?
+            `).all(this.tenantId, workspaceId, safeLimit)
+            : this.db.prepare(`
+                SELECT *
+                FROM task_assets
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND deleted_at IS NULL
+                ORDER BY path ASC
+                LIMIT ?
+            `).all(this.tenantId, workspaceId, safeLimit);
+        return rows.map(mapRow);
+    }
+    upsertSyncEntry(entryInput) {
+        const entry = {
+            ...entryInput,
+            workspaceId: normalizeWorkspaceId(entryInput.workspaceId),
+            path: normalizePath(entryInput.path),
+            provider: entryInput.provider === 'r2' ? 'r2' : 'local',
+            version: Number(entryInput.version || 1),
+            contentType: entryInput.contentType || 'application/octet-stream',
+            sizeBytes: Number(entryInput.sizeBytes || 0),
+            sha256: String(entryInput.sha256 || ''),
+            uploadedAt: String(entryInput.uploadedAt || entryInput.updatedAt || new Date().toISOString()),
+            updatedAt: String(entryInput.updatedAt || entryInput.uploadedAt || new Date().toISOString()),
+            deletedAt: entryInput.deletedAt ? String(entryInput.deletedAt) : null,
+            purgeAfter: entryInput.purgeAfter ? String(entryInput.purgeAfter) : null,
+            quarantineStatus: entryInput.quarantineStatus || 'none',
+            scan: {
+                engine: entryInput.scan?.engine || 'none',
+                verdict: entryInput.scan?.verdict || 'clean',
+                details: entryInput.scan?.details,
+                scannedAt: String(entryInput.scan?.scannedAt || entryInput.updatedAt || entryInput.uploadedAt || new Date().toISOString())
             }
-        }
-        const refreshed = this.db.prepare(`
-            SELECT *
-            FROM task_assets
-            WHERE tenant_id = ?
-            ORDER BY path ASC
-            LIMIT ?
-        `).all(this.tenantId, safeLimit);
-        return refreshed.map(mapRow);
+        };
+        this.upsertEntry(entry);
+        return this.get(entry.path, entry.workspaceId) || entry;
+    }
+    applySyncDelete(pathValue, deletedAt, workspaceIdRaw) {
+        const normalizedPath = normalizePath(pathValue);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw || inferWorkspaceIdFromPath(normalizedPath));
+        const entry = this.get(normalizedPath, workspaceId);
+        if (!entry)
+            return null;
+        const effectiveDeletedAt = String(deletedAt || new Date().toISOString());
+        this.db.prepare(`
+            UPDATE task_assets
+            SET deleted_at = ?, purge_after = NULL, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND path = ?
+        `).run(effectiveDeletedAt, effectiveDeletedAt, this.tenantId, workspaceId, normalizedPath);
+        return this.get(normalizedPath, workspaceId);
     }
     updateQuarantineStatus(pathValue, quarantineStatus, workspaceIdRaw) {
         const entry = this.get(pathValue, workspaceIdRaw);

package/dist/storage/workspaceAssetStore.d.ts

@@ -0,0 +1,122 @@
+import type { DatabaseAdapter } from './databaseAdapter.js';
+import type { ObjectStorageProvider } from './objectStorage.js';
+export type WorkspaceAssetKind = 'document' | 'image' | 'file';
+export type WorkspaceAssetScanStatus = 'pending' | 'clean' | 'infected' | 'failed';
+export type WorkspaceAssetLinkRole = 'attachment' | 'image' | 'reference';
+export interface WorkspaceAssetEntry {
+    assetId: string;
+    tenantId: string;
+    workspaceId: string;
+    kind: WorkspaceAssetKind;
+    logicalName: string | null;
+    originalFilename: string;
+    mimeType: string;
+    storageProvider: ObjectStorageProvider;
+    storageKey: string;
+    contentSha256: string;
+    sizeBytes: number;
+    documentId: string | null;
+    referenceNumber: number | null;
+    version: number | null;
+    isLatest: boolean;
+    scanStatus: WorkspaceAssetScanStatus;
+    scanEngine: string | null;
+    scanDetails: string | null;
+    createdByUserId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+    purgeAfter: string | null;
+}
+export interface WorkspaceAssetLinkEntry {
+    tenantId: string;
+    workspaceId: string;
+    assetId: string;
+    taskId: string;
+    role: WorkspaceAssetLinkRole;
+    displayName: string | null;
+    sortOrder: number | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+export declare class WorkspaceAssetStore {
+    private readonly db;
+    private readonly tenantId;
+    constructor(db: DatabaseAdapter, tenantId: string);
+    private normalizePersistedAsset;
+    get(assetIdRaw: string, workspaceIdRaw?: string): WorkspaceAssetEntry | null;
+    getByStorageKey(storageKeyRaw: string, workspaceIdRaw: string): WorkspaceAssetEntry | null;
+    getByKindAndReferenceNumber(workspaceIdRaw: string, kind: WorkspaceAssetKind, referenceNumberRaw: unknown): WorkspaceAssetEntry | null;
+    upsertAsset(input: {
+        assetId: string;
+        workspaceId: string;
+        kind: WorkspaceAssetKind;
+        logicalName?: string | null;
+        originalFilename: string;
+        mimeType: string;
+        storageProvider: ObjectStorageProvider;
+        storageKey: string;
+        contentSha256: string;
+        sizeBytes: number;
+        documentId?: string | null;
+        referenceNumber?: number | null;
+        version?: number | null;
+        isLatest?: boolean;
+        scanStatus?: WorkspaceAssetScanStatus;
+        scanEngine?: string | null;
+        scanDetails?: string | null;
+        createdByUserId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+        deletedAt?: string | null;
+        purgeAfter?: string | null;
+        allowReferenceNumberReassignment?: boolean;
+    }): WorkspaceAssetEntry;
+    private reserveAssetReferenceNumber;
+    private findNextAvailableReadableAssetReferenceNumber;
+    listByWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+        kind?: WorkspaceAssetKind;
+        limit?: number;
+        offset?: number;
+    }): WorkspaceAssetEntry[];
+    listAllByWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+        kind?: WorkspaceAssetKind;
+        pageSize?: number;
+    }): WorkspaceAssetEntry[];
+    listAll(options?: {
+        includeDeleted?: boolean;
+        kind?: WorkspaceAssetKind;
+        limit?: number;
+    }): WorkspaceAssetEntry[];
+    listQuarantined(limitRaw?: number): WorkspaceAssetEntry[];
+    listPurgeCandidates(now?: Date, limitRaw?: number): WorkspaceAssetEntry[];
+    markDeleted(assetIdRaw: string, workspaceIdRaw: string, deletedAt?: string, purgeAfter?: string | null): WorkspaceAssetEntry | null;
+    remove(assetIdRaw: string, workspaceIdRaw: string): boolean;
+    upsertLink(input: {
+        workspaceId: string;
+        assetId: string;
+        taskId: string;
+        role: WorkspaceAssetLinkRole;
+        displayName?: string | null;
+        sortOrder?: number | null;
+        createdAt?: string;
+        updatedAt?: string;
+        deletedAt?: string | null;
+    }): WorkspaceAssetLinkEntry;
+    listLinksForTask(taskIdRaw: string, workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): WorkspaceAssetLinkEntry[];
+    listLinksForAsset(assetIdRaw: string, workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): WorkspaceAssetLinkEntry[];
+    deleteLink(input: {
+        workspaceId: string;
+        assetId: string;
+        taskId: string;
+        role: WorkspaceAssetLinkRole;
+        hardDelete?: boolean;
+    }): boolean;
+}