The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
[codex] Improve runtime and import reliability (#6549)
Dottaad6effa65c6c
diff --git a/cli/src/commands/routines.ts b/cli/src/commands/routines.tsindex 4c5a3ca967..63ff89d81f 100644--- a/cli/src/commands/routines.ts+++ b/cli/src/commands/routines.ts@@ -9,6 +9,7 @@ import {createEmbeddedPostgresLogBuffer,ensurePostgresDatabase,formatEmbeddedPostgresError,+ prepareEmbeddedPostgresNativeRuntime,routines,} from "@paperclipai/db";import { eq, inArray } from "drizzle-orm";@@ -116,6 +117,7 @@ async function ensureEmbeddedPostgres(dataDir: string, preferredPort: number): P"Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again.",);}+ await prepareEmbeddedPostgresNativeRuntime();const postmasterPidFile = path.resolve(dataDir, "postmaster.pid");const runningPid = readRunningPostmasterPid(postmasterPidFile);diff --git a/cli/src/commands/worktree.ts b/cli/src/commands/worktree.tsindex fea6f2c3ec..db0ca00814 100644--- a/cli/src/commands/worktree.ts+++ b/cli/src/commands/worktree.ts@@ -45,6 +45,7 @@ import {runDatabaseRestore,createEmbeddedPostgresLogBuffer,formatEmbeddedPostgresError,+ prepareEmbeddedPostgresNativeRuntime,} from "@paperclipai/db";import type { Command } from "commander";import { ensureAgentJwtSecret, loadPaperclipEnvFile, mergePaperclipEnvEntries, readPaperclipEnvEntries, resolvePaperclipEnvFile } from "../config/env.js";@@ -1059,6 +1060,7 @@ async function ensureEmbeddedPostgres(dataDir: string, preferredPort: number): P"Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again.",);}+ await prepareEmbeddedPostgresNativeRuntime();const postmasterPidFile = path.resolve(dataDir, "postmaster.pid");const runningPid = readRunningPostmasterPid(postmasterPidFile);diff --git a/packages/db/src/embedded-postgres-native.test.ts b/packages/db/src/embedded-postgres-native.test.tsnew file mode 100644index 0000000000..7335f2c649--- /dev/null+++ b/packages/db/src/embedded-postgres-native.test.ts@@ -0,0 +1,43 @@+import fs from "node:fs";+import os from "node:os";+import path from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import { ensureLinuxSharedLibraryAliases } from "./embedded-postgres-native.js";++describe("embedded Postgres native runtime", () => {+ const tempDirs: string[] = [];++ afterEach(() => {+ for (const tempDir of tempDirs.splice(0)) {+ fs.rmSync(tempDir, { recursive: true, force: true });+ }+ });++ it.runIf(process.platform !== "win32")("creates soname aliases for bundled patch-level shared libraries", async () => {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-embedded-pg-libs-"));+ tempDirs.push(tempDir);+ fs.writeFileSync(path.join(tempDir, "libicuuc.so.60.2"), "");+ fs.writeFileSync(path.join(tempDir, "libicui18n.so.60.2"), "");+ fs.writeFileSync(path.join(tempDir, "README.md"), "");++ const created = await ensureLinuxSharedLibraryAliases(tempDir);++ expect(created.map((file) => path.basename(file)).sort()).toEqual([+ "libicui18n.so.60",+ "libicuuc.so.60",+ ]);+ expect(fs.readlinkSync(path.join(tempDir, "libicuuc.so.60"))).toBe("libicuuc.so.60.2");+ });++ it.runIf(process.platform !== "win32")("is idempotent when aliases already exist", async () => {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-embedded-pg-libs-"));+ tempDirs.push(tempDir);+ fs.writeFileSync(path.join(tempDir, "libicuuc.so.60.2"), "");++ await ensureLinuxSharedLibraryAliases(tempDir);+ const second = await ensureLinuxSharedLibraryAliases(tempDir);++ expect(second).toEqual([]);+ expect(fs.readlinkSync(path.join(tempDir, "libicuuc.so.60"))).toBe("libicuuc.so.60.2");+ });+});diff --git a/packages/db/src/embedded-postgres-native.ts b/packages/db/src/embedded-postgres-native.tsnew file mode 100644index 0000000000..a304f8a18e--- /dev/null+++ b/packages/db/src/embedded-postgres-native.ts@@ -0,0 +1,85 @@+import { promises as fs } from "node:fs";+import { createRequire } from "node:module";+import path from "node:path";++const require = createRequire(import.meta.url);++function resolveNativePackageName(): string | null {+ if (process.platform !== "linux") return null;++ switch (process.arch) {+ case "arm64":+ return "linux-arm64";+ case "arm":+ return "linux-arm";+ case "ia32":+ return "linux-ia32";+ case "ppc64":+ return "linux-ppc64";+ case "x64":+ return "linux-x64";+ default:+ return null;+ }+}++async function pathExists(value: string): Promise<boolean> {+ try {+ await fs.stat(value);+ return true;+ } catch {+ return false;+ }+}++function resolveEmbeddedPostgresPackageRoot(): string | null {+ try {+ const entry = require.resolve("embedded-postgres");+ return path.dirname(path.dirname(entry));+ } catch {+ return null;+ }+}++function prependPathEnv(name: string, value: string): void {+ const current = process.env[name] ?? "";+ const parts = current.split(path.delimiter).filter(Boolean);+ if (parts.includes(value)) return;+ process.env[name] = [value, ...parts].join(path.delimiter);+}++export async function ensureLinuxSharedLibraryAliases(libDir: string): Promise<string[]> {+ const entries = await fs.readdir(libDir, { withFileTypes: true });+ const created: string[] = [];++ for (const entry of entries) {+ if (!entry.isFile()) continue;+ const match = entry.name.match(/^(lib.+\.so\.\d+)\.\d+(?:\.\d+)?$/);+ if (!match) continue;++ const aliasName = match[1];+ const aliasPath = path.join(libDir, aliasName);+ try {+ await fs.symlink(entry.name, aliasPath);+ created.push(aliasPath);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;+ throw error;+ }+ }++ return created;+}++export async function prepareEmbeddedPostgresNativeRuntime(): Promise<void> {+ const nativePackageName = resolveNativePackageName();+ const packageRoot = resolveEmbeddedPostgresPackageRoot();+ if (!nativePackageName || !packageRoot) return;++ const nativeRoot = path.resolve(packageRoot, "..", "@embedded-postgres", nativePackageName);+ const libDir = path.join(nativeRoot, "native", "lib");+ if (!(await pathExists(libDir))) return;++ prependPathEnv("LD_LIBRARY_PATH", libDir);+ await ensureLinuxSharedLibraryAliases(libDir);+}diff --git a/packages/db/src/index.ts b/packages/db/src/index.tsindex 3bf4d22b57..a1c5bce8b2 100644--- a/packages/db/src/index.ts+++ b/packages/db/src/index.ts@@ -30,6 +30,10 @@ export {createEmbeddedPostgresLogBuffer,formatEmbeddedPostgresError,} from "./embedded-postgres-error.js";+export {+ ensureLinuxSharedLibraryAliases,+ prepareEmbeddedPostgresNativeRuntime,+} from "./embedded-postgres-native.js";export { issueRelations } from "./schema/issue_relations.js";export { issueReferenceMentions } from "./schema/issue_reference_mentions.js";export * from "./schema/index.js";diff --git a/packages/db/src/migration-runtime.ts b/packages/db/src/migration-runtime.tsindex 5aa2b6a27d..3823b6d02e 100644--- a/packages/db/src/migration-runtime.ts+++ b/packages/db/src/migration-runtime.ts@@ -3,6 +3,7 @@ import { createServer } from "node:net";import path from "node:path";import { ensurePostgresDatabase, getPostgresDataDirectory } from "./client.js";import { createEmbeddedPostgresLogBuffer, formatEmbeddedPostgresError } from "./embedded-postgres-error.js";+import { prepareEmbeddedPostgresNativeRuntime } from "./embedded-postgres-native.js";import { resolveDatabaseTarget } from "./runtime-config.js";type EmbeddedPostgresInstance = {@@ -92,6 +93,7 @@ async function ensureEmbeddedPostgresConnection(preferredPort: number,): Promise<MigrationConnection> {const EmbeddedPostgres = await loadEmbeddedPostgresCtor();+ await prepareEmbeddedPostgresNativeRuntime();const selectedPort = await findAvailablePort(preferredPort);const postmasterPidFile = path.resolve(dataDir, "postmaster.pid");const pgVersionFile = path.resolve(dataDir, "PG_VERSION");diff --git a/packages/db/src/test-embedded-postgres.ts b/packages/db/src/test-embedded-postgres.tsindex 87db5cde96..929d17c5f7 100644--- a/packages/db/src/test-embedded-postgres.ts+++ b/packages/db/src/test-embedded-postgres.ts@@ -3,6 +3,7 @@ import net from "node:net";import os from "node:os";import path from "node:path";import { applyPendingMigrations, ensurePostgresDatabase } from "./client.js";+import { prepareEmbeddedPostgresNativeRuntime } from "./embedded-postgres-native.js";type EmbeddedPostgresInstance = {initialise(): Promise<void>;@@ -48,6 +49,7 @@ function getReservedTestPorts(): Set<number> {async function getEmbeddedPostgresCtor(): Promise<EmbeddedPostgresCtor> {const mod = await import("embedded-postgres");+ await prepareEmbeddedPostgresNativeRuntime();return mod.default as EmbeddedPostgresCtor;}diff --git a/server/src/__tests__/company-portability-routes.test.ts b/server/src/__tests__/company-portability-routes.test.tsindex 26f6df1680..4259052537 100644--- a/server/src/__tests__/company-portability-routes.test.ts+++ b/server/src/__tests__/company-portability-routes.test.ts@@ -139,6 +139,58 @@ function createExportResult() {};}+const importRequest = {+ source: { type: "inline", files: { "COMPANY.md": "---\nname: Test\n---\n" } },+ include: { company: true, agents: true, projects: false, issues: false },+ target: { mode: "existing_company", companyId },+ collisionStrategy: "rename",+};++const cloudHeaders = {+ "x-paperclip-cloud-stack-id": "stack-alpha",+ "x-paperclip-cloud-paperclip-company-id": companyId,+};++function cloudTenantActor() {+ return {+ type: "board",+ userId: "cloud-user-1",+ userName: "Cloud User",+ userEmail: "[email protected]",+ companyIds: [companyId],+ memberships: [{ companyId, membershipRole: "owner", status: "active" }],+ isInstanceAdmin: true,+ source: "cloud_tenant",+ };+}++function createImportResult(action = "updated") {+ return {+ company: { id: companyId, action },+ agents: [{ id: "agent-1" }],+ warnings: [],+ };+}++async function waitForImportJobStatus(app: express.Express, statusUrl: string, status: string) {+ for (let attempt = 0; attempt < 20; attempt += 1) {+ const res = await request(app).get(statusUrl).set(cloudHeaders);+ if (res.body.job?.status === status) {+ return res;+ }+ await new Promise((resolve) => setTimeout(resolve, 10));+ }+ throw new Error(`Timed out waiting for import job to reach ${status}`);+}++async function waitForCondition(condition: () => boolean, label: string) {+ for (let attempt = 0; attempt < 20; attempt += 1) {+ if (condition()) return;+ await new Promise((resolve) => setTimeout(resolve, 10));+ }+ throw new Error(`Timed out waiting for ${label}`);+}+describe.sequential("company portability routes", () => {beforeEach(() => {vi.clearAllMocks();@@ -426,4 +478,116 @@ describe.sequential("company portability routes", () => {expect(res.body.error).toContain("Instance admin");expect(mockCompanyPortabilityService.importBundle).not.toHaveBeenCalled();});++ it.sequential("accepts trusted Cloud async import jobs and reports success by job id", async () => {+ let resolveImport: (value: ReturnType<typeof createImportResult>) => void = () => undefined;+ const pendingImport = new Promise<ReturnType<typeof createImportResult>>((resolve) => {+ resolveImport = resolve;+ });+ mockCompanyPortabilityService.importBundle.mockReturnValueOnce(pendingImport);+ const app = await createApp(cloudTenantActor());++ const accepted = await request(app)+ .post("/api/companies/import")+ .set("x-paperclip-cloud-async-import", "1")+ .set(cloudHeaders)+ .send(importRequest);++ expect(accepted.status).toBe(202);+ expect(accepted.body.job.status).toBe("running");+ expect(accepted.body.statusUrl).toMatch(/^\/api\/companies\/import\/jobs\/tenant-import-/);+ expect(accepted.body.retryAfterMs).toBe(1000);+ await waitForCondition(() => mockCompanyPortabilityService.importBundle.mock.calls.length === 1, "import job start");+ expect(mockCompanyPortabilityService.importBundle).toHaveBeenCalledWith(importRequest, "cloud-user-1");+ expect(mockLogActivity).not.toHaveBeenCalled();++ resolveImport(createImportResult("updated"));+ const succeeded = await waitForImportJobStatus(app, accepted.body.statusUrl, "succeeded");++ expect(succeeded.status).toBe(200);+ expect(succeeded.body.job.status).toBe("succeeded");+ expect(succeeded.body.job.result.companyId).toBe(companyId);+ expect(succeeded.body.retryAfterMs).toBeUndefined();+ expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({+ action: "company.imported",+ companyId,+ details: expect.objectContaining({+ agentCount: 1,+ warningCount: 0,+ companyAction: "updated",+ }),+ }));++ const nowSpy = vi.spyOn(Date, "now").mockReturnValue(Date.parse(succeeded.body.job.completedAt) + (5 * 60 * 1000) + 1);+ try {+ const expired = await request(app).get(accepted.body.statusUrl).set(cloudHeaders);+ expect(expired.status).toBe(404);+ expect(expired.body.error).toBe("Import job not found");+ } finally {+ nowSpy.mockRestore();+ }+ });++ it.sequential("reports trusted Cloud async import job failures with the tenant error message", async () => {+ mockCompanyPortabilityService.importBundle.mockRejectedValueOnce(new Error("tenant import exploded"));+ const app = await createApp(cloudTenantActor());++ const accepted = await request(app)+ .post("/api/companies/import")+ .set("x-paperclip-cloud-async-import", "1")+ .set(cloudHeaders)+ .send(importRequest);++ expect(accepted.status).toBe(202);+ const failed = await waitForImportJobStatus(app, accepted.body.statusUrl, "failed");++ expect(failed.status).toBe(200);+ expect(failed.body.job.status).toBe("failed");+ expect(failed.body.job.error.message).toBe("tenant import exploded");+ expect(failed.body.retryAfterMs).toBeUndefined();+ expect(failed.body.message).toBe("tenant import exploded");+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it.sequential("accepts trusted Cloud async import jobs before validating the full import payload", async () => {+ const app = await createApp(cloudTenantActor());++ const accepted = await request(app)+ .post("/api/companies/import")+ .set("x-paperclip-cloud-async-import", "1")+ .set(cloudHeaders)+ .send({ target: { mode: "existing_company", companyId } });++ expect(accepted.status).toBe(202);+ expect(accepted.body.job.status).toBe("running");+ expect(mockCompanyPortabilityService.importBundle).not.toHaveBeenCalled();++ const failed = await waitForImportJobStatus(app, accepted.body.statusUrl, "failed");++ expect(failed.status).toBe(200);+ expect(failed.body.job.status).toBe("failed");+ expect(failed.body.job.error.message).toEqual(expect.any(String));+ expect(mockCompanyPortabilityService.importBundle).not.toHaveBeenCalled();+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it.sequential("keeps global import apply synchronous when Cloud async opt-in is absent", async () => {+ mockCompanyPortabilityService.importBundle.mockResolvedValueOnce(createImportResult("created"));+ const app = await createApp(cloudTenantActor());++ const res = await request(app)+ .post("/api/companies/import")+ .set(cloudHeaders)+ .send(importRequest);++ expect(res.status).toBe(200);+ expect(res.body.company.id).toBe(companyId);+ expect(res.body.company.action).toBe("created");+ expect(res.body.job).toBeUndefined();+ expect(mockCompanyPortabilityService.importBundle).toHaveBeenCalledWith(importRequest, "cloud-user-1");+ expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({+ action: "company.imported",+ companyId,+ }));+ });});diff --git a/server/src/index.ts b/server/src/index.tsindex d9c52d27d6..38caf44a51 100644--- a/server/src/index.ts+++ b/server/src/index.ts@@ -15,6 +15,7 @@ import {inspectMigrations,applyPendingMigrations,createEmbeddedPostgresLogBuffer,+ prepareEmbeddedPostgresNativeRuntime,reconcilePendingMigrationHistory,formatDatabaseBackupResult,runDatabaseBackup,@@ -318,6 +319,7 @@ export async function startServer(): Promise<StartedServer> {"Embedded PostgreSQL mode requires dependency `embedded-postgres`. Reinstall dependencies (without omitting required packages), or set DATABASE_URL for external Postgres.",);}+ await prepareEmbeddedPostgresNativeRuntime();const dataDir = resolve(config.embeddedPostgresDataDir);const configuredPort = config.embeddedPostgresPort;diff --git a/server/src/routes/companies.ts b/server/src/routes/companies.tsindex 2de26afbe1..3fe9664fcd 100644--- a/server/src/routes/companies.ts+++ b/server/src/routes/companies.ts@@ -1,3 +1,4 @@+import { randomUUID } from "node:crypto";import { Router, type Request } from "express";import type { Db } from "@paperclipai/db";import {@@ -35,6 +36,8 @@ export function companyRoutes(db: Db, storage?: StorageService) {const access = accessService(db);const budgets = budgetService(db);const feedback = feedbackService(db);+ const importJobs = new Map<string, ImportJobRecord>();+ const importJobTerminalRetentionMs = 5 * 60 * 1000;function parseBooleanQuery(value: unknown) {return value === true || value === "true" || value === "1";@@ -177,27 +180,47 @@ export function companyRoutes(db: Db, storage?: StorageService) {res.json(preview);});- router.post(COMPANY_IMPORT_ROUTE_PATH, validate(companyPortabilityImportSchema), async (req, res) => {+ router.get("/import/jobs/:jobId", async (req, res) => {+ assertCloudTenantCaller(req);+ cleanupTerminalImportJobs(importJobs, importJobTerminalRetentionMs);+ const job = importJobs.get(req.params.jobId as string);+ if (!job || job.cloudTenantKey !== cloudTenantRequestKey(req)) {+ res.status(404).json({ error: "Import job not found" });+ return;+ }+ res.json(importJobResponse(job));+ });++ router.post(COMPANY_IMPORT_ROUTE_PATH, async (req, res) => {assertBoard(req);- assertImportTargetAccess(req, req.body.target);+ const rawImportBody: unknown = req.body;const actor = getActorInfo(req);- const result = await portability.importBundle(req.body, req.actor.type === "board" ? req.actor.userId : null);- await logActivity(db, {- companyId: result.company.id,- actorType: actor.actorType,- actorId: actor.actorId,- action: "company.imported",- entityType: "company",- entityId: result.company.id,- agentId: actor.agentId,- runId: actor.runId,- details: {- include: req.body.include ?? null,- agentCount: result.agents.length,- warningCount: result.warnings.length,- companyAction: result.company.action,- },- });+ const boardUserId = req.actor.type === "board" ? req.actor.userId : null;+ if (req.header("x-paperclip-cloud-async-import") === "1") {+ assertCloudTenantCaller(req);+ cleanupTerminalImportJobs(importJobs, importJobTerminalRetentionMs);+ const job = createImportJob(cloudTenantRequestKey(req));+ importJobs.set(job.id, job);+ const operation = async () => {+ const importBody = companyPortabilityImportSchema.parse(rawImportBody);+ assertImportTargetAccess(req, importBody.target);+ const activity = importedCompanyActivityContext(actor, importBody.include ?? null);+ const result = await portability.importBundle(importBody, boardUserId);+ await logImportedCompanyActivity(db, activity, result);+ return result;+ };+ res.status(202).json(importJobAcceptedResponse(job));+ setImmediate(() => {+ void runImportJob(job, operation);+ });+ return;+ }++ const importBody = companyPortabilityImportSchema.parse(rawImportBody);+ assertImportTargetAccess(req, importBody.target);+ const activity = importedCompanyActivityContext(actor, importBody.include ?? null);+ const result = await portability.importBundle(importBody, boardUserId);+ await logImportedCompanyActivity(db, activity, result);res.json(result);});@@ -419,3 +442,166 @@ export function companyRoutes(db: Db, storage?: StorageService) {return router;}++type CompanyImportResult = {+ company: { id: string; action: unknown };+ agents: unknown[];+ warnings: unknown[];+};++interface ImportJobRecord {+ id: string;+ cloudTenantKey: string;+ status: "running" | "succeeded" | "failed";+ createdAt: string;+ updatedAt: string;+ completedAt?: string;+ error?: { message: string };+ result?: {+ companyId: string;+ agentCount: number;+ warningCount: number;+ companyAction: unknown;+ };+}++interface ImportedCompanyActivityContext {+ actorType: "user" | "agent";+ actorId: string;+ agentId: string | null;+ runId: string | null;+ include: unknown;+}++function assertCloudTenantCaller(req: Request) {+ if (req.actor.source !== "cloud_tenant") {+ throw forbidden("Trusted Cloud tenant access required");+ }+}++function cloudTenantRequestKey(req: Request) {+ return [+ req.actor.userId ?? "",+ req.header("x-paperclip-cloud-stack-id")?.trim() ?? "",+ req.header("x-paperclip-cloud-paperclip-company-id")?.trim() ?? "",+ ].join(":");+}++function createImportJob(cloudTenantKey: string): ImportJobRecord {+ const now = new Date().toISOString();+ return {+ id: `tenant-import-${randomUUID()}`,+ cloudTenantKey,+ status: "running",+ createdAt: now,+ updatedAt: now,+ };+}++async function runImportJob(+ job: ImportJobRecord,+ operation: () => Promise<CompanyImportResult>,+) {+ try {+ const result = await operation();+ const now = new Date().toISOString();+ job.status = "succeeded";+ job.updatedAt = now;+ job.completedAt = now;+ job.result = {+ companyId: result.company.id,+ agentCount: result.agents.length,+ warningCount: result.warnings.length,+ companyAction: result.company.action,+ };+ } catch (error) {+ const now = new Date().toISOString();+ job.status = "failed";+ job.updatedAt = now;+ job.completedAt = now;+ job.error = { message: errorMessage(error) };+ }+}++function importedCompanyActivityContext(+ actor: ReturnType<typeof getActorInfo>,+ include: unknown,+): ImportedCompanyActivityContext {+ return {+ actorType: actor.actorType,+ actorId: actor.actorId,+ agentId: actor.agentId,+ runId: actor.runId,+ include,+ };+}++async function logImportedCompanyActivity(+ db: Db,+ activity: ImportedCompanyActivityContext,+ result: CompanyImportResult,+) {+ await logActivity(db, {+ companyId: result.company.id,+ actorType: activity.actorType,+ actorId: activity.actorId,+ action: "company.imported",+ entityType: "company",+ entityId: result.company.id,+ agentId: activity.agentId,+ runId: activity.runId,+ details: {+ include: activity.include,+ agentCount: result.agents.length,+ warningCount: result.warnings.length,+ companyAction: result.company.action,+ },+ });+}++function importJobAcceptedResponse(job: ImportJobRecord) {+ return {+ job: {+ id: job.id,+ status: job.status,+ },+ statusUrl: `/api/companies/import/jobs/${encodeURIComponent(job.id)}`,+ retryAfterMs: 1000,+ };+}++function importJobResponse(job: ImportJobRecord) {+ const isTerminal = job.status === "succeeded" || job.status === "failed";+ const response: Record<string, unknown> = {+ job: {+ id: job.id,+ status: job.status,+ createdAt: job.createdAt,+ updatedAt: job.updatedAt,+ ...(job.completedAt ? { completedAt: job.completedAt } : {}),+ ...(job.error ? { error: job.error } : {}),+ ...(job.result ? { result: job.result } : {}),+ },+ ...(isTerminal ? {} : { retryAfterMs: 1000 }),+ };+ if (job.error?.message) {+ response.error = job.error.message;+ response.message = job.error.message;+ response.reason = job.error.message;+ }+ return response;+}++function cleanupTerminalImportJobs(importJobs: Map<string, ImportJobRecord>, terminalRetentionMs: number) {+ const now = Date.now();+ for (const [jobId, job] of importJobs) {+ if (job.status === "running" || !job.completedAt) continue;+ if (now - Date.parse(job.completedAt) > terminalRetentionMs) {+ importJobs.delete(jobId);+ }+ }+}++function errorMessage(error: unknown) {+ return error instanceof Error && error.message.trim() ? error.message : String(error);+}