streamby-core 0.38.0 → 0.40.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 0.40.0
+
+### ⚠️ Breaking changes
+
+- **A project's render farm connections are its workers.** `GET`, `POST` and
+  `DELETE /projects/:projectId/render-farm-connections` are now
+  `/projects/:projectId/workers`, which takes `{ name, provider?, endpoint, credential?, kinds,
+  categories, autoKind?, timeoutSeconds?, description? }`. They're still kept in the project's
+  `renderFarmConnections` list.
+- **Jobs are kept in the main database** (a new `jobs` table, created at startup, or collection),
+  not in memory: they survive restarts and every instance sees them. `GET /jobs/:jobId` answers
+  from there.
+- `canUseBuiltin` may be called with kind `'worker'`.
+
+### Added
+
+- **Processing workers**: StreamBy sends jobs to external workers (the host's, in the router
+  config's `workers`; or a project's own) and keeps what they make, as a new asset derived from
+  the original or as the asset's new version, with the worker's report. The README documents the
+  contract a worker follows.
+  - `POST /projects/:projectId/jobs/process` asks for one; `GET /projects/:projectId/jobs` lists
+    a project's jobs; `POST /projects/:projectId/jobs/:jobId/retry` sends a failed one again.
+  - Workers call back to `/worker-jobs/:jobId/{progress,upload-url,complete,fail}` with a token
+    of that job's attempt alone.
+  - A job not taken, or not finished in time, is sent again (up to `workerOptions.maxAttempts`);
+    every instance looks for them (`workerOptions.sweepIntervalMs`), and only one sends each.
+  - A worker with an `autoKind` runs by itself on an asset of its categories marked as a
+    deliverable, unless it's marked with an API token without `jobs:run`.
+  - **Behind a proxy that ends TLS, set `workerOptions.callbackBaseUrl`** to the router's public
+    https URL: without it, the callback URL is made from the request (`req.protocol`), and comes
+    out as `http://`.
+  - A project's worker is reached only over https and never at a local, private, shared,
+    benchmarking, multicast or reserved address: neither as its endpoint is written nor as its
+    name resolves, checked when it's connected and again right before each job is sent. A job
+    for one that resolves to such an address fails for good. `workerOptions.allowLocalEndpoints`
+    lifts that, for development. Its credential is used only while whoever connected it is
+    still in the project.
+  - A worker's answer to a job it doesn't take is logged, not shown: the job says "The worker
+    refused the job".
+  - A job is sent as whoever asked for it, with the platform role they had then (a host's
+    `canUseBuiltin` decides on sending it as on asking for it).
+- MCP tools `list_workers`, `process_asset`, `list_jobs` and `retry_job`.
+- Deleting a project deletes its jobs.
+- Job events (`jobEvent`) carry the job's `projectId` and `status`.
+
+### Fixed
+
+- **Instances starting together don't deadlock on StreamBy's tables.** The statements that make
+  them (or bring them up to date) at startup run one instance at a time, in a transaction that
+  holds a transaction-level advisory lock (so it works behind a pooler in transaction mode, such
+  as Supabase's).
+
+## 0.39.0
+
+### Added
+
+- **Every resource of a project has its own list**, so a client fetches the one it shows instead
+  of the whole project (which still carries them all). New: `GET /projects/:id/exports` (what
+  each export is, as the project lists them: not its schema nor its credentials),
+  `GET /projects/:id/integrations` and `GET /projects/:id/origins`. They answer `{ data }`, as
+  the existing lists do (`connections`, `connections/db`, `connections/storage`, `members`,
+  `pipelines`, `workflow`), and are for the project's members. With an API token, the exports
+  need `exports:read` and the other two `project:read`.
+
 ## 0.38.0
 
 ### Added

package/README.md

@@ -201,7 +201,9 @@ A token sees only the tools whose permissions it has.
 | `create_pipeline`, `update_pipeline` | `workflow:write` |
 | `list_exports` | `project:read` and `exports:read` |
 | `get_export` | `exports:read` |
-| `get_job` | `jobs:read` |
+| `get_job`, `list_jobs` | `jobs:read` |
+| `list_workers` | `project:read` |
+| `process_asset`, `retry_job` | `jobs:run` |
 | `list_sequences`, `list_shots`, `list_tasks` | `production:read` |
 | `update_sequence`, `update_shot`, `update_task` | `production:write` |
 | `create_sequence`, `create_shot`, `create_task` | `production:write` and `workflow:write` |
@@ -339,6 +341,111 @@ The claude.ai connector needs OAuth, which isn't available yet: it's for API tok
 
 ---
 
+## ⚙️ Processing workers
+
+StreamBy doesn't process assets itself (optimizing a glTF, making LODs, transcoding...): it
+sends the work to a **worker**, an external service, and keeps what it makes. Anyone can write a
+compatible worker by following the contract below.
+
+**Where workers come from**
+
+- **The host's**, offered to every project, in the router config (each one gated, like the other
+  built-ins, by `canUseBuiltin` with kind `'worker'`):
+
+  ```ts
+  createStreamByRouter({
+    // ...
+    workers: [{
+      id: 'gltf', name: 'glTF optimizer',
+      endpoint: 'https://worker.example.com/jobs', credential: process.env.GLTF_WORKER_TOKEN,
+      kinds: ['gltf-optimize', 'lod'],   // what it does
+      categories: ['3d-models'],         // the assets it takes
+      autoKind: 'gltf-optimize',         // optional: run on its own (see below)
+      timeoutSeconds: 3600,              // optional: how long it may take a job
+    }],
+    workerOptions: {
+      callbackBaseUrl: 'https://api.example.com/streamby', // where workers call back (see below)
+      maxAttempts: 3,           // how many times a job is sent before it fails
+      sweepIntervalMs: 30_000,  // how often each instance looks for jobs to send again
+    },
+  });
+  ```
+
+- **A project's own**, connected from the project (`GET`, `POST` and
+  `DELETE /projects/:projectId/workers`; a project's render farms are workers too). Its endpoint
+  must be https and never reach a local or private address: not as written, nor as its name
+  resolves, which is checked when it's connected and again right before each job is sent (a
+  name can point at the server's own network, or start pointing there later). A job for one
+  that resolves to such an address fails for good. `workerOptions.allowLocalEndpoints` lifts
+  all this, for development. Its credential is stored encrypted, and used only while whoever
+  connected it is still in the project.
+
+  The host's own workers aren't checked this way: the host chose them, and they may well be on
+  its private network.
+
+`GET /projects/:projectId/workers` lists the workers a member can use.
+
+**Asking for a job**
+
+`POST /projects/:projectId/jobs/process` with
+`{ assetId, versionId?, worker: { source: 'builtin' | 'project', id }, kind, profile?, resultMode? }`
+(editors and admins; an API token needs `jobs:run`, and the MCP server has `process_asset`).
+`resultMode` decides where the result goes:
+
+- `'derived'` (the default): a new asset, linked to the original (`derivedFrom`), which is never
+  touched;
+- `'version'`: the asset's new version, at its own key, so its URL serves the result; the
+  version it replaces is archived, and can still be downloaded.
+
+A worker with an `autoKind` also runs by itself on an asset of its categories when it's marked
+as a deliverable (by a session, or by an API token that has `jobs:run`: one without it marks the
+deliverable and starts nothing).
+
+Jobs are kept in the main database (a `jobs` table or collection): they survive restarts, and
+every instance sees them. `GET /projects/:projectId/jobs` lists them (`?assetId=` for one asset's);
+`POST /projects/:projectId/jobs/:jobId/retry` sends a failed one again.
+
+**The contract: what a worker receives**
+
+StreamBy sends each job with a `POST` to the worker's endpoint
+(`Authorization: Bearer <the worker's credential>`):
+
+```json
+{
+  "jobId": "…", "kind": "gltf-optimize", "profile": { "textureFormat": "ktx2" }, "attempt": 1,
+  "asset": { "id": "…", "versionId": null, "fileName": "hero.glb", "contentType": "model/gltf-binary", "category": "3d-models" },
+  "download": { "url": "https://…signed…", "expiresAt": "…" },
+  "callback": { "url": "https://api.example.com/streamby/worker-jobs/<jobId>", "token": "…" },
+  "deadline": "…"
+}
+```
+
+The worker answers `2xx` to take it (any other answer, or none, and the job is sent again later),
+downloads the asset with `download.url`, and does its work before `deadline`.
+
+`callback.url` is `workerOptions.callbackBaseUrl` plus the job's path. Without it, it's made
+from the request that asked for the job (`req.protocol` and its host): behind a proxy that ends
+TLS (and without Express's `trust proxy`), that comes out as `http://`, which a worker can't call
+back to. Set `callbackBaseUrl` to the router's public https URL.
+
+**The contract: what a worker calls back**
+
+Every callback is a `POST` to `callback.url` plus an action, with
+`Authorization: Bearer <callback.token>`. The token is the job's for this attempt alone: a
+callback without it, with another, or after the job ended answers 401.
+
+| Action | Body | Answer |
+|---|---|---|
+| `/progress` | `{ "progress": 0-100, "stage": "optimizing" }` (either) | the job |
+| `/upload-url` | `{ "fileName": "hero.glb", "contentType": "model/gltf-binary" }` (of the asset's category) | `{ "url", "method": "PUT", "headers", "expiresAt" }`: upload the result there |
+| `/complete` | `{ "report": { … } }` (optional; any JSON object, kept with the result) | the job, completed, with its `result`: `{ assetId, versionId, mode }` |
+| `/fail` | `{ "error": "…", "retryable": false }` | the job, failed with its error (sent again if `retryable` and attempts are left) |
+
+A job its worker doesn't complete before its deadline is sent again, up to
+`workerOptions.maxAttempts` times; then it fails, with its error, and can be retried.
+
+---
+
 ## 👥 Project roles
 
 What a user can do in a project depends on their role in that project, as an active member

package/dist/adapters/database/connectionManager.js

@@ -41,7 +41,28 @@ const getConnection = (id) => {
     return clientEntry;
 };
 exports.getConnection = getConnection;
+// StreamBy's tables, made (or brought up to date) at startup. Several instances starting at once
+// against the same database would deadlock on these statements, so one runs them at a time:
+// in a transaction holding a transaction-level advisory lock, which ends with it. (A session
+// lock could outlive its unlock behind a pooler in transaction mode, such as Supabase's, which
+// may run the unlock on another connection, and block every later startup.)
 const ensureTablesExist = async (pool) => {
+    const client = await pool.connect();
+    try {
+        await client.query('BEGIN');
+        await client.query(`SELECT pg_advisory_xact_lock(hashtext('streamby:ensure-tables'))`);
+        await createTables(client);
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        await client.query('ROLLBACK').catch(() => { });
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+};
+const createTables = async (pool) => {
     try {
         await pool.query(`
       CREATE SCHEMA IF NOT EXISTS streamby;
@@ -179,6 +200,40 @@ const ensureTablesExist = async (pool) => {
       CREATE INDEX IF NOT EXISTS api_tokens_kind_idx ON streamby.api_tokens (kind);
     `);
         console.log('✅ "api_tokens" table ensured to exist.');
+        // Jobs (see services/jobStore): kept here so they survive restarts and every instance sees
+        // them. Main db only, like the tables above.
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.jobs (
+        id               TEXT PRIMARY KEY,
+        "jobType"        VARCHAR(40) NOT NULL,
+        "userId"         VARCHAR(255) NOT NULL,
+        "projectId"      VARCHAR(255) NOT NULL,
+        "assetId"        VARCHAR(255),
+        status           VARCHAR(20) NOT NULL,
+        stage            VARCHAR(60) NOT NULL,
+        progress         INTEGER NOT NULL DEFAULT 0,
+        payload          JSONB NOT NULL DEFAULT '{}',
+        error            TEXT,
+        worker           JSONB,
+        kind             VARCHAR(100),
+        profile          JSONB,
+        "versionId"      VARCHAR(255),
+        "resultMode"     VARCHAR(20),
+        attempts         INTEGER NOT NULL DEFAULT 0,
+        "maxAttempts"    INTEGER NOT NULL DEFAULT 1,
+        "nextAttemptAt"  TIMESTAMP WITH TIME ZONE,
+        "leaseUntil"     TIMESTAMP WITH TIME ZONE,
+        "callbackHash"   CHAR(64),
+        upload           JSONB,
+        report           JSONB,
+        result           JSONB,
+        "createdAt"      TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+        "updatedAt"      TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS jobs_project_idx ON streamby.jobs ("projectId", "createdAt");
+      CREATE INDEX IF NOT EXISTS jobs_due_idx ON streamby.jobs (status, "nextAttemptAt") WHERE worker IS NOT NULL;
+    `);
+        console.log('✅ "jobs" table ensured to exist.');
         // The MCP server's audit log: every tool call (see mcp/audit). Main db only.
         await pool.query(`
       CREATE TABLE IF NOT EXISTS streamby.mcp_audit (

package/dist/mcp/tools.js

@@ -317,6 +317,47 @@ exports.TOOLS = [
         projectOf: byProject,
         call: ({ projectId, deliverableId }) => ({ method: 'DELETE', path: `/projects/${enc(projectId)}/deliverables/${enc(deliverableId)}` }),
     }),
+    // ── Processing (workers) ──
+    tool({
+        name: 'list_workers', title: 'List workers', permissions: ['project:read'],
+        description: "The processing workers a project can use: the host's and the project's own (each one's id, source, what it does — its kinds — and the asset categories it takes). They show in the project's Workers settings.",
+        input: { projectId },
+        projectOf: byProject,
+        call: ({ projectId }) => ({ method: 'GET', path: `/projects/${enc(projectId)}/workers` }),
+        pick: (data) => data?.data ?? [],
+    }),
+    tool({
+        name: 'process_asset', title: 'Process an asset', permissions: ['jobs:run'], write: true,
+        description: "Asks a worker to process an asset (or one of its versions), e.g. optimize a glTF. The result is kept as a new asset derived from it (resultMode 'derived', the default: the original is untouched) or as the asset's new version ('version': its URL then serves the result). It runs in the background: follow it with get_job or list_jobs; it shows in the file's Jobs tab, in Storage.",
+        input: {
+            projectId,
+            assetId: id('asset'),
+            versionId: zod_1.z.string().optional().describe('A version (list_asset_versions); the latest if not given'),
+            worker: zod_1.z.object({ source: zod_1.z.enum(['builtin', 'project']), id: zod_1.z.string().min(1) }).describe('A worker, from list_workers'),
+            kind: zod_1.z.string().min(1).describe("What it should do: one of the worker's kinds"),
+            profile: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().describe("Options for the worker (e.g. { \"textureFormat\": \"ktx2\" })"),
+            resultMode: zod_1.z.enum(['derived', 'version']).optional(),
+        },
+        projectOf: byProject,
+        call: ({ projectId, ...fields }) => ({ method: 'POST', path: `/projects/${enc(projectId)}/jobs/process`, body: defined(fields) }),
+        pick: (data) => data?.job,
+    }),
+    tool({
+        name: 'list_jobs', title: 'List jobs', permissions: ['jobs:read'],
+        description: "A project's jobs, newest first (of one asset if given): their status, stage, progress, error and, when done, their worker's report and result.",
+        input: { projectId, assetId: zod_1.z.string().optional() },
+        projectOf: byProject,
+        call: ({ projectId, assetId }) => ({ method: 'GET', path: `/projects/${enc(projectId)}/jobs${assetId ? `?${new URLSearchParams({ assetId })}` : ''}` }),
+        pick: (data) => data?.data ?? [],
+    }),
+    tool({
+        name: 'retry_job', title: 'Retry a job', permissions: ['jobs:run'], write: true,
+        description: "Sends a failed worker job to its worker again.",
+        input: { projectId, jobId: id('job') },
+        projectOf: byProject,
+        call: ({ projectId, jobId }) => ({ method: 'POST', path: `/projects/${enc(projectId)}/jobs/${enc(jobId)}/retry` }),
+        pick: (data) => data?.job,
+    }),
     // ── Projects ──
     tool({
         name: 'create_project', title: 'Create a project', permissions: ['projects:create'], write: true,

package/dist/middleware/createRouter.js

@@ -15,6 +15,7 @@ const auth_1 = require("../services/auth");
 const apiToken_1 = require("./routes/apiToken");
 const mcp_1 = require("./routes/mcp");
 const encryption_1 = require("../utils/encryption");
+const jobStore_1 = require("../services/jobStore");
 const auth_2 = require("./routes/auth");
 const user_1 = require("./routes/user");
 const export_1 = require("./routes/export");
@@ -38,11 +39,15 @@ const production_1 = require("./routes/production");
 const rights_1 = require("./routes/rights");
 const workflow_1 = require("./routes/workflow");
 const pipeline_1 = require("./routes/pipeline");
+const worker_1 = require("./routes/worker");
+const workerCallback_1 = require("./routes/workerCallback");
+const workerJobs_1 = require("../services/workerJobs");
 const deliverable_1 = require("./routes/deliverable");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
         (0, encryption_1.setEncryptionKey)(config.encrypt, config.encryptPreviousKeys);
+    (0, jobStore_1.setJobStoreDatabase)(config);
     // Establish DB connections asynchronously (Postgres/Mongo + schema migrations).
     // Until they're ready, HOLD incoming requests instead of letting them through —
     // route handlers resolve projects/exports (e.g. the /menu-list export) against a
@@ -69,6 +74,8 @@ function createStreamByRouter(config) {
     })
         .finally(() => {
         ready = true;
+        // Jobs left pending (or with their worker's time up) by a restart are sent again.
+        (0, workerJobs_1.startWorkerSweeper)({ ...config, adapter });
     });
     router.use((_req, _res, next) => {
         if (ready)
@@ -108,6 +115,8 @@ function createStreamByRouter(config) {
     // /auth answers whether there's a session (it reads it itself); everything after needs one,
     // but for the public export route (see authenticate).
     router.use((0, auth_2.authRouter)(config));
+    // Workers call back with their job's token, not a session (see routes/workerCallback).
+    router.use((0, workerCallback_1.workerCallbackRouter)({ ...config, adapter }));
     router.use((0, auth_1.authenticate)(config));
     router.use(auth_1.enforceApiTokenScope);
     router.use(subscription_1.ensureSubscription);
@@ -135,6 +144,7 @@ function createStreamByRouter(config) {
     router.use((0, rights_1.rightsRouter)(config));
     router.use((0, workflow_1.workflowRouter)(config));
     router.use((0, pipeline_1.pipelineRouter)(config));
-    router.use((0, deliverable_1.deliverableRouter)(config));
+    router.use((0, worker_1.workerRouter)({ ...config, adapter }));
+    router.use((0, deliverable_1.deliverableRouter)({ ...config, adapter }));
     return router;
 }

package/dist/middleware/routes/ai.js

@@ -31,7 +31,7 @@ function aiRouter(_config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('transcription', auth.userId, projectId, { fileId, model, sourceLanguage, outputFormats, provider, credentialId });
+            const job = await (0, jobQueue_1.createJob)('transcription', auth.userId, projectId, { fileId, model, sourceLanguage, outputFormats, provider, credentialId });
             setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, { model, sourceLanguage, outputFormats, provider, credentialId }));
             res.status(202).json({ jobId: job.jobId, status: job.status });
         }
@@ -52,7 +52,7 @@ function aiRouter(_config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('upscale', auth.userId, projectId, { fileId, scale, model, mode, credentialId });
+            const job = await (0, jobQueue_1.createJob)('upscale', auth.userId, projectId, { fileId, scale, model, mode, credentialId });
             setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, { scale, model, mode, credentialId }));
             res.status(202).json({ jobId: job.jobId, status: job.status });
         }
@@ -73,7 +73,7 @@ function aiRouter(_config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('generate-asset', auth.userId, projectId, { assetType, provider, prompt, seed, credentialId });
+            const job = await (0, jobQueue_1.createJob)('generate-asset', auth.userId, projectId, { assetType, provider, prompt, seed, credentialId });
             setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, { assetType, provider, prompt, seed, credentialId }));
             res.status(202).json({ jobId: job.jobId, status: job.status });
         }

package/dist/middleware/routes/deliverable.d.ts

@@ -1,3 +1,5 @@
 import { Router } from 'express';
-import { StreamByConfig } from '../../types';
-export declare function deliverableRouter(_config: StreamByConfig): Router;
+import { StorageAdapter, StreamByConfig } from '../../types';
+export declare function deliverableRouter(config: StreamByConfig & {
+    adapter?: StorageAdapter;
+}): Router;

package/dist/middleware/routes/deliverable.js

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deliverableRouter = deliverableRouter;
 const express_1 = require("express");
+const workerJobs_1 = require("../../services/workerJobs");
+const worker_1 = require("./worker");
+const auth_1 = require("../../services/auth");
 const manager_1 = require("../../models/manager");
-const auth_1 = require("../../utils/auth");
+const auth_2 = require("../../utils/auth");
 const nosqlDb_1 = require("../../utils/nosqlDb");
 const assetVersions_1 = require("../../services/assetVersions");
 const deliverables_1 = require("../../services/deliverables");
 const MAX_NOTE = 1000;
 // A project's deliverables (see services/deliverables): marked, listed and removed. Removing
-// one never deletes its asset.
-function deliverableRouter(_config) {
+// one never deletes its asset. Marking one starts the workers set to process its kind of asset
+// by themselves.
+function deliverableRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
     const exportsOf = (project) => project.exports ?? [];
@@ -48,7 +52,7 @@ function deliverableRouter(_config) {
             const project = await Project.findOne({ _id: projectId });
             if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+            if (!(0, auth_2.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
             const deliverables = await (0, deliverables_1.listDeliverables)(projectId, { shotId, exportId });
             res.json({ deliverables: await describe(project, deliverables) });
@@ -77,7 +81,7 @@ function deliverableRouter(_config) {
             const project = await Project.findOne({ _id: projectId });
             if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            if (!(0, auth_1.canEditProject)(project, auth.userId))
+            if (!(0, auth_2.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
             const db = (0, nosqlDb_1.nosqlDb)();
             if (!db)
@@ -104,7 +108,12 @@ function deliverableRouter(_config) {
                 createdBy: auth.userId,
             });
             const [described] = await describe(project, [deliverable]);
-            res.status(201).json({ deliverable: described });
+            // The project's workers set to process its kind of asset by themselves start on it: not
+            // for an API token that can't run jobs.
+            const jobs = (0, auth_1.tokenAllows)(auth.apiToken, 'jobs:run')
+                ? await (0, workerJobs_1.enqueueAutomaticJobs)(project, assetId, versionId || null, auth, config, (0, worker_1.callbackBaseOf)(req, config)).catch(() => [])
+                : [];
+            res.status(201).json({ deliverable: described, jobs: jobs.map(workerJobs_1.publicJob) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to mark the deliverable', details: err.message });
@@ -117,7 +126,7 @@ function deliverableRouter(_config) {
             const project = await Project.findOne({ _id: projectId });
             if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            if (!(0, auth_1.canEditProject)(project, auth.userId))
+            if (!(0, auth_2.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
             if (!(await (0, deliverables_1.deleteDeliverable)(projectId, deliverableId)))
                 return res.status(404).json({ message: 'Deliverable not found' });

package/dist/middleware/routes/export.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportRouter = exportRouter;
 const express_1 = require("express");
 const deliverables_1 = require("../../services/deliverables");
+const sanitize_1 = require("../../utils/sanitize");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
@@ -61,6 +62,21 @@ const DEFAULT_NODE_SCHEMA = {
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
+    // ─── A project's exports, on their own ────────────────────────────────────
+    router.get('/projects/:id/exports', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            return res.status(200).json({ data: (0, sanitize_1.exportSummaries)(project.exports) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch exports', details: err.message });
+        }
+    });
     router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);

package/dist/middleware/routes/media.js

@@ -8,6 +8,7 @@ const jobQueue_1 = require("../../services/jobQueue");
 const mediaProcessor_1 = require("../../services/mediaProcessor");
 const storage_1 = require("../../providers/storage");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
+const workerJobs_1 = require("../../services/workerJobs");
 const auth_2 = require("../../services/auth");
 function getMetadataCollection() {
     const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
@@ -31,7 +32,7 @@ function mediaRouter(config) {
     router.get('/jobs/:jobId', async (req, res) => {
         try {
             const auth = req.auth;
-            const job = (0, jobQueue_1.getJob)(req.params.jobId);
+            const job = await (0, jobQueue_1.getJob)(req.params.jobId);
             if (!job)
                 return res.status(404).json({ message: 'Job not found' });
             // With an API token, only a job of a project it reaches.
@@ -42,7 +43,7 @@ function mediaRouter(config) {
                 if (!(0, auth_1.isProjectMember)(project, auth.userId))
                     return res.status(404).json({ message: 'Job not found' });
             }
-            res.json({ job });
+            res.json({ job: (0, workerJobs_1.publicJob)(job) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch job', details: err.message });
@@ -61,7 +62,7 @@ function mediaRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('ingest', auth.userId, projectId, { fileId });
+            const job = await (0, jobQueue_1.createJob)('ingest', auth.userId, projectId, { fileId });
             // Run async — response returns immediately with jobId
             setImmediate(() => (0, mediaProcessor_1.runIngestJob)(job.jobId, fileId, projectId));
             res.status(202).json({ jobId: job.jobId, status: job.status });
@@ -83,7 +84,7 @@ function mediaRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('transcode', auth.userId, projectId, {
+            const job = await (0, jobQueue_1.createJob)('transcode', auth.userId, projectId, {
                 fileId, codec, resolution, outputFormat, bitrate, audioCodec,
             });
             setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, { codec, resolution, outputFormat, bitrate, audioCodec }, adapter));
@@ -106,7 +107,7 @@ function mediaRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('thumbnail', auth.userId, projectId, { fileId, timecode, resolution, strategy });
+            const job = await (0, jobQueue_1.createJob)('thumbnail', auth.userId, projectId, { fileId, timecode, resolution, strategy });
             setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, { timecode, resolution, strategy }));
             res.status(202).json({ jobId: job.jobId, status: job.status });
         }
@@ -127,7 +128,7 @@ function mediaRouter(config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.canEditProject)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            const job = (0, jobQueue_1.createJob)('caption', auth.userId, projectId, { fileId, sourceLanguage, outputFormat, provider });
+            const job = await (0, jobQueue_1.createJob)('caption', auth.userId, projectId, { fileId, sourceLanguage, outputFormat, provider });
             setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, { sourceLanguage, outputFormat, provider }));
             res.status(202).json({ jobId: job.jobId, status: job.status });
         }

package/dist/middleware/routes/project.js

@@ -12,6 +12,7 @@ const auth_2 = require("../../services/auth");
 const apiTokens_1 = require("../../services/apiTokens");
 const nosqlDb_1 = require("../../utils/nosqlDb");
 const production_1 = require("../../services/production");
+const jobStore_1 = require("../../services/jobStore");
 function projectRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -196,15 +197,7 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const exports = (project.exports || []).map((e) => ({
-                id: e.id,
-                name: e.name,
-                description: e.description,
-                method: e.method,
-                private: e.private,
-                useConnections: e.useConnections,
-                useCredentials: e.useCredentials,
-            }));
+            const exports = (0, sanitize_1.exportSummaries)(project.exports);
             const sanitized = (0, sanitize_1.sanitizeProject)({ ...project, id: project._id || project.id, _id: undefined, connections: project.connections || [], exports });
             // Whether it has production data, for its Production section to show even without a
             // production node in its workflow.
@@ -262,9 +255,12 @@ function projectRouter(config) {
                 return res.status(403).json({ message: 'Only a project admin can delete it' });
             }
             await Project.useDbType(project.dbType).delete({ _id: projectId });
-            // Its tokens have nothing left to reach, and its production data nothing to belong to.
+            // Its tokens have nothing left to reach, and its production data and jobs nothing to
+            // belong to.
             await (0, apiTokens_1.deleteProjectApiTokens)(String(projectId));
             await (0, production_1.deleteProductionData)(String(projectId));
+            if (projectId)
+                await (0, jobStore_1.jobStore)().deleteProject(String(projectId));
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
@@ -381,6 +377,21 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to update project image', details: err.message });
         }
     });
+    // ─── A project's allowed origins, on their own ────────────────────────────
+    router.get('/projects/:id/origins', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            return res.status(200).json({ data: project.allowedOrigin || [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project origins', details: err.message });
+        }
+    });
     router.patch('/projects/:id/origins', async (req, res) => {
         try {
             const auth = req.auth;
@@ -403,6 +414,21 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to update project origins', details: err.message });
         }
     });
+    // ─── A project's integrations, on their own ───────────────────────────────
+    router.get('/projects/:id/integrations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            return res.status(200).json({ data: (0, sanitize_1.sanitizeIntegrationConnections)(project.integrationConnections) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project integrations', details: err.message });
+        }
+    });
     // ─── Add an integration to an existing project ───────────────────────────
     router.post('/projects/:id/integrations', async (req, res) => {
         try {