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
Fix dev migration prompt and embedded db:migrate
Dotta56aeddfa1cf2
diff --git a/doc/DATABASE.md b/doc/DATABASE.mdindex 8f46f3827e..d2425d14d9 100644--- a/doc/DATABASE.md+++ b/doc/DATABASE.md@@ -19,6 +19,14 @@ That's it. On first start the server:Data persists across restarts in `~/.paperclip/instances/default/db/`. To reset local dev data, delete that directory.+If you need to apply pending migrations manually, run:++```sh+pnpm db:migrate+```++When `DATABASE_URL` is unset, this command targets the current embedded PostgreSQL instance for your active Paperclip config/instance.+This mode is ideal for local development and one-command installs.Docker note: the Docker quickstart image also uses embedded PostgreSQL by default. Persist `/paperclip` to keep DB state across container restarts (see `doc/DOCKER.md`).diff --git a/package.json b/package.jsonindex b2e23d55b1..61f9968ecf 100644--- a/package.json+++ b/package.json@@ -4,7 +4,7 @@"type": "module","scripts": {"dev": "node scripts/dev-runner.mjs watch",- "dev:watch": "cross-env PAPERCLIP_MIGRATION_PROMPT=never node scripts/dev-runner.mjs watch",+ "dev:watch": "node scripts/dev-runner.mjs watch","dev:once": "node scripts/dev-runner.mjs dev","dev:server": "pnpm --filter @paperclipai/server dev","dev:ui": "pnpm --filter @paperclipai/ui dev",diff --git a/packages/db/src/migrate.ts b/packages/db/src/migrate.tsindex b4c7b975eb..f51b629e2c 100644--- a/packages/db/src/migrate.ts+++ b/packages/db/src/migrate.ts@@ -1,21 +1,29 @@import { applyPendingMigrations, inspectMigrations } from "./client.js";+import { resolveMigrationConnection } from "./migration-runtime.js";-const url = process.env.DATABASE_URL;+async function main(): Promise<void> {+ const resolved = await resolveMigrationConnection();-if (!url) {- throw new Error("DATABASE_URL is required for db:migrate");-}+ console.log(`Migrating database via ${resolved.source}`);++ try {+ const before = await inspectMigrations(resolved.connectionString);+ if (before.status === "upToDate") {+ console.log("No pending migrations");+ return;+ }-const before = await inspectMigrations(url);-if (before.status === "upToDate") {- console.log("No pending migrations");-} else {- console.log(`Applying ${before.pendingMigrations.length} pending migration(s)...`);- await applyPendingMigrations(url);+ console.log(`Applying ${before.pendingMigrations.length} pending migration(s)...`);+ await applyPendingMigrations(resolved.connectionString);- const after = await inspectMigrations(url);- if (after.status !== "upToDate") {- throw new Error(`Migrations incomplete: ${after.pendingMigrations.join(", ")}`);+ const after = await inspectMigrations(resolved.connectionString);+ if (after.status !== "upToDate") {+ throw new Error(`Migrations incomplete: ${after.pendingMigrations.join(", ")}`);+ }+ console.log("Migrations complete");+ } finally {+ await resolved.stop();}- console.log("Migrations complete");}++await main();diff --git a/packages/db/src/migration-runtime.ts b/packages/db/src/migration-runtime.tsnew file mode 100644index 0000000000..bc90b76295--- /dev/null+++ b/packages/db/src/migration-runtime.ts@@ -0,0 +1,134 @@+import { existsSync, readFileSync, rmSync } from "node:fs";+import { createRequire } from "node:module";+import path from "node:path";+import { fileURLToPath, pathToFileURL } from "node:url";+import { ensurePostgresDatabase } from "./client.js";+import { resolveDatabaseTarget } from "./runtime-config.js";++type EmbeddedPostgresInstance = {+ initialise(): Promise<void>;+ start(): Promise<void>;+ stop(): Promise<void>;+};++type EmbeddedPostgresCtor = new (opts: {+ databaseDir: string;+ user: string;+ password: string;+ port: number;+ persistent: boolean;+ onLog?: (message: unknown) => void;+ onError?: (message: unknown) => void;+}) => EmbeddedPostgresInstance;++export type MigrationConnection = {+ connectionString: string;+ source: string;+ stop: () => Promise<void>;+};++function readRunningPostmasterPid(postmasterPidFile: string): number | null {+ if (!existsSync(postmasterPidFile)) return null;+ try {+ const pid = Number(readFileSync(postmasterPidFile, "utf8").split("\n")[0]?.trim());+ if (!Number.isInteger(pid) || pid <= 0) return null;+ process.kill(pid, 0);+ return pid;+ } catch {+ return null;+ }+}++function readPidFilePort(postmasterPidFile: string): number | null {+ if (!existsSync(postmasterPidFile)) return null;+ try {+ const lines = readFileSync(postmasterPidFile, "utf8").split("\n");+ const port = Number(lines[3]?.trim());+ return Number.isInteger(port) && port > 0 ? port : null;+ } catch {+ return null;+ }+}++async function loadEmbeddedPostgresCtor(): Promise<EmbeddedPostgresCtor> {+ const require = createRequire(import.meta.url);+ const resolveCandidates = [+ path.resolve(fileURLToPath(new URL("../..", import.meta.url))),+ path.resolve(fileURLToPath(new URL("../../server", import.meta.url))),+ path.resolve(fileURLToPath(new URL("../../cli", import.meta.url))),+ process.cwd(),+ ];++ try {+ const resolvedModulePath = require.resolve("embedded-postgres", { paths: resolveCandidates });+ const mod = await import(pathToFileURL(resolvedModulePath).href);+ return mod.default as EmbeddedPostgresCtor;+ } catch {+ throw new Error(+ "Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again.",+ );+ }+}++async function ensureEmbeddedPostgresConnection(+ dataDir: string,+ preferredPort: number,+): Promise<MigrationConnection> {+ const EmbeddedPostgres = await loadEmbeddedPostgresCtor();+ const postmasterPidFile = path.resolve(dataDir, "postmaster.pid");+ const runningPid = readRunningPostmasterPid(postmasterPidFile);+ const runningPort = readPidFilePort(postmasterPidFile);++ if (runningPid) {+ const port = runningPort ?? preferredPort;+ const adminConnectionString = `postgres://paperclip:[email protected]:${port}/postgres`;+ await ensurePostgresDatabase(adminConnectionString, "paperclip");+ return {+ connectionString: `postgres://paperclip:[email protected]:${port}/paperclip`,+ source: `embedded-postgres@${port}`,+ stop: async () => {},+ };+ }++ const instance = new EmbeddedPostgres({+ databaseDir: dataDir,+ user: "paperclip",+ password: "paperclip",+ port: preferredPort,+ persistent: true,+ onLog: () => {},+ onError: () => {},+ });++ if (!existsSync(path.resolve(dataDir, "PG_VERSION"))) {+ await instance.initialise();+ }+ if (existsSync(postmasterPidFile)) {+ rmSync(postmasterPidFile, { force: true });+ }+ await instance.start();++ const adminConnectionString = `postgres://paperclip:[email protected]:${preferredPort}/postgres`;+ await ensurePostgresDatabase(adminConnectionString, "paperclip");++ return {+ connectionString: `postgres://paperclip:[email protected]:${preferredPort}/paperclip`,+ source: `embedded-postgres@${preferredPort}`,+ stop: async () => {+ await instance.stop();+ },+ };+}++export async function resolveMigrationConnection(): Promise<MigrationConnection> {+ const target = resolveDatabaseTarget();+ if (target.mode === "postgres") {+ return {+ connectionString: target.connectionString,+ source: target.source,+ stop: async () => {},+ };+ }++ return ensureEmbeddedPostgresConnection(target.dataDir, target.port);+}diff --git a/packages/db/src/migration-status.ts b/packages/db/src/migration-status.tsnew file mode 100644index 0000000000..3d0cc8f43e--- /dev/null+++ b/packages/db/src/migration-status.ts@@ -0,0 +1,45 @@+import { inspectMigrations } from "./client.js";+import { resolveMigrationConnection } from "./migration-runtime.js";++const jsonMode = process.argv.includes("--json");++async function main(): Promise<void> {+ const connection = await resolveMigrationConnection();++ try {+ const state = await inspectMigrations(connection.connectionString);+ const payload =+ state.status === "upToDate"+ ? {+ source: connection.source,+ status: "upToDate" as const,+ tableCount: state.tableCount,+ pendingMigrations: [] as string[],+ }+ : {+ source: connection.source,+ status: "needsMigrations" as const,+ tableCount: state.tableCount,+ pendingMigrations: state.pendingMigrations,+ reason: state.reason,+ };++ if (jsonMode) {+ console.log(JSON.stringify(payload));+ return;+ }++ if (payload.status === "upToDate") {+ console.log(`Database is up to date via ${payload.source}`);+ return;+ }++ console.log(+ `Pending migrations via ${payload.source}: ${payload.pendingMigrations.join(", ")}`,+ );+ } finally {+ await connection.stop();+ }+}++await main();diff --git a/packages/db/src/runtime-config.test.ts b/packages/db/src/runtime-config.test.tsnew file mode 100644index 0000000000..55371e094b--- /dev/null+++ b/packages/db/src/runtime-config.test.ts@@ -0,0 +1,107 @@+import fs from "node:fs";+import os from "node:os";+import path from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import { resolveDatabaseTarget } from "./runtime-config.js";++const ORIGINAL_CWD = process.cwd();+const ORIGINAL_ENV = { ...process.env };++function writeJson(filePath: string, value: unknown) {+ fs.mkdirSync(path.dirname(filePath), { recursive: true });+ fs.writeFileSync(filePath, JSON.stringify(value, null, 2));+}++function writeText(filePath: string, value: string) {+ fs.mkdirSync(path.dirname(filePath), { recursive: true });+ fs.writeFileSync(filePath, value);+}++afterEach(() => {+ process.chdir(ORIGINAL_CWD);+ for (const key of Object.keys(process.env)) {+ if (!(key in ORIGINAL_ENV)) delete process.env[key];+ }+ for (const [key, value] of Object.entries(ORIGINAL_ENV)) {+ if (value === undefined) delete process.env[key];+ else process.env[key] = value;+ }+});++describe("resolveDatabaseTarget", () => {+ it("uses DATABASE_URL from process env first", () => {+ process.env.DATABASE_URL = "postgres://env-user:[email protected]:5432/paperclip";++ const target = resolveDatabaseTarget();++ expect(target).toMatchObject({+ mode: "postgres",+ connectionString: "postgres://env-user:[email protected]:5432/paperclip",+ source: "DATABASE_URL",+ });+ });++ it("uses DATABASE_URL from repo-local .paperclip/.env", () => {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-db-runtime-"));+ const projectDir = path.join(tempDir, "repo");+ fs.mkdirSync(projectDir, { recursive: true });+ process.chdir(projectDir);+ writeJson(path.join(projectDir, ".paperclip", "config.json"), {+ database: { mode: "embedded-postgres", embeddedPostgresPort: 54329 },+ });+ writeText(+ path.join(projectDir, ".paperclip", ".env"),+ 'DATABASE_URL="postgres://file-user:[email protected]:6543/paperclip"\n',+ );++ const target = resolveDatabaseTarget();++ expect(target).toMatchObject({+ mode: "postgres",+ connectionString: "postgres://file-user:[email protected]:6543/paperclip",+ source: "paperclip-env",+ });+ });++ it("uses config postgres connection string when configured", () => {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-db-runtime-"));+ const configPath = path.join(tempDir, "instance", "config.json");+ process.env.PAPERCLIP_CONFIG = configPath;+ writeJson(configPath, {+ database: {+ mode: "postgres",+ connectionString: "postgres://cfg-user:[email protected]:5432/paperclip",+ },+ });++ const target = resolveDatabaseTarget();++ expect(target).toMatchObject({+ mode: "postgres",+ connectionString: "postgres://cfg-user:[email protected]:5432/paperclip",+ source: "config.database.connectionString",+ });+ });++ it("falls back to embedded postgres settings from config", () => {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-db-runtime-"));+ const configPath = path.join(tempDir, "instance", "config.json");+ process.env.PAPERCLIP_CONFIG = configPath;+ writeJson(configPath, {+ database: {+ mode: "embedded-postgres",+ embeddedPostgresDataDir: "~/paperclip-test-db",+ embeddedPostgresPort: 55444,+ },+ });++ const target = resolveDatabaseTarget();++ expect(target).toMatchObject({+ mode: "embedded-postgres",+ dataDir: path.resolve(os.homedir(), "paperclip-test-db"),+ port: 55444,+ source: "embedded-postgres@55444",+ });+ });+});diff --git a/packages/db/src/runtime-config.ts b/packages/db/src/runtime-config.tsnew file mode 100644index 0000000000..c6c64a38fa--- /dev/null+++ b/packages/db/src/runtime-config.ts@@ -0,0 +1,267 @@+import { existsSync, readFileSync } from "node:fs";+import os from "node:os";+import path from "node:path";++const DEFAULT_INSTANCE_ID = "default";+const CONFIG_BASENAME = "config.json";+const ENV_BASENAME = ".env";+const INSTANCE_ID_RE = /^[a-zA-Z0-9_-]+$/;++type PartialConfig = {+ database?: {+ mode?: "embedded-postgres" | "postgres";+ connectionString?: string;+ embeddedPostgresDataDir?: string;+ embeddedPostgresPort?: number;+ pgliteDataDir?: string;+ pglitePort?: number;+ };+};++export type ResolvedDatabaseTarget =+ | {+ mode: "postgres";+ connectionString: string;+ source: "DATABASE_URL" | "paperclip-env" | "config.database.connectionString";+ configPath: string;+ envPath: string;+ }+ | {+ mode: "embedded-postgres";+ dataDir: string;+ port: number;+ source: `embedded-postgres@${number}`;+ configPath: string;+ envPath: string;+ };++function expandHomePrefix(value: string): string {+ if (value === "~") return os.homedir();+ if (value.startsWith("~/")) return path.resolve(os.homedir(), value.slice(2));+ return value;+}++function resolvePaperclipHomeDir(): string {+ const envHome = process.env.PAPERCLIP_HOME?.trim();+ if (envHome) return path.resolve(expandHomePrefix(envHome));+ return path.resolve(os.homedir(), ".paperclip");+}++function resolvePaperclipInstanceId(): string {+ const raw = process.env.PAPERCLIP_INSTANCE_ID?.trim() || DEFAULT_INSTANCE_ID;+ if (!INSTANCE_ID_RE.test(raw)) {+ throw new Error(`Invalid PAPERCLIP_INSTANCE_ID '${raw}'.`);+ }+ return raw;+}++function resolveDefaultConfigPath(): string {+ return path.resolve(+ resolvePaperclipHomeDir(),+ "instances",+ resolvePaperclipInstanceId(),+ CONFIG_BASENAME,+ );+}++function resolveDefaultEmbeddedPostgresDir(): string {+ return path.resolve(resolvePaperclipHomeDir(), "instances", resolvePaperclipInstanceId(), "db");+}++function resolveHomeAwarePath(value: string): string {+ return path.resolve(expandHomePrefix(value));+}++function findConfigFileFromAncestors(startDir: string): string | null {+ let currentDir = path.resolve(startDir);++ while (true) {+ const candidate = path.resolve(currentDir, ".paperclip", CONFIG_BASENAME);+ if (existsSync(candidate)) return candidate;++ const nextDir = path.resolve(currentDir, "..");+ if (nextDir === currentDir) return null;+ currentDir = nextDir;+ }+}++function resolvePaperclipConfigPath(): string {+ if (process.env.PAPERCLIP_CONFIG?.trim()) {+ return path.resolve(process.env.PAPERCLIP_CONFIG.trim());+ }+ return findConfigFileFromAncestors(process.cwd()) ?? resolveDefaultConfigPath();+}++function resolvePaperclipEnvPath(configPath: string): string {+ return path.resolve(path.dirname(configPath), ENV_BASENAME);+}++function parseEnvFile(contents: string): Record<string, string> {+ const entries: Record<string, string> = {};++ for (const rawLine of contents.split(/\r?\n/)) {+ const line = rawLine.trim();+ if (!line || line.startsWith("#")) continue;++ const match = rawLine.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);+ if (!match) continue;++ const [, key, rawValue] = match;+ const value = rawValue.trim();+ if (!value) {+ entries[key] = "";+ continue;+ }++ if (+ (value.startsWith("\"") && value.endsWith("\"")) ||+ (value.startsWith("'") && value.endsWith("'"))+ ) {+ entries[key] = value.slice(1, -1);+ continue;+ }++ entries[key] = value.replace(/\s+#.*$/, "").trim();+ }++ return entries;+}++function readEnvEntries(envPath: string): Record<string, string> {+ if (!existsSync(envPath)) return {};+ return parseEnvFile(readFileSync(envPath, "utf8"));+}++function migrateLegacyConfig(raw: unknown): PartialConfig | null {+ if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;++ const config = { ...(raw as Record<string, unknown>) };+ const databaseRaw = config.database;+ if (typeof databaseRaw !== "object" || databaseRaw === null || Array.isArray(databaseRaw)) {+ return config;+ }++ const database = { ...(databaseRaw as Record<string, unknown>) };+ if (database.mode === "pglite") {+ database.mode = "embedded-postgres";++ if (+ typeof database.embeddedPostgresDataDir !== "string" &&+ typeof database.pgliteDataDir === "string"+ ) {+ database.embeddedPostgresDataDir = database.pgliteDataDir;+ }+ if (+ typeof database.embeddedPostgresPort !== "number" &&+ typeof database.pglitePort === "number" &&+ Number.isFinite(database.pglitePort)+ ) {+ database.embeddedPostgresPort = database.pglitePort;+ }+ }++ config.database = database;+ return config as PartialConfig;+}++function asPositiveInt(value: unknown): number | null {+ if (typeof value !== "number" || !Number.isFinite(value)) return null;+ const rounded = Math.trunc(value);+ return rounded > 0 ? rounded : null;+}++function readConfig(configPath: string): PartialConfig | null {+ if (!existsSync(configPath)) return null;++ let parsed: unknown;+ try {+ parsed = JSON.parse(readFileSync(configPath, "utf8"));+ } catch (err) {+ throw new Error(+ `Failed to parse config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`,+ );+ }++ const migrated = migrateLegacyConfig(parsed);+ if (migrated === null || typeof migrated !== "object" || Array.isArray(migrated)) {+ throw new Error(`Invalid config at ${configPath}: expected a JSON object`);+ }++ const database =+ typeof migrated.database === "object" &&+ migrated.database !== null &&+ !Array.isArray(migrated.database)+ ? migrated.database+ : undefined;++ return {+ database: database+ ? {+ mode: database.mode === "postgres" ? "postgres" : "embedded-postgres",+ connectionString:+ typeof database.connectionString === "string" ? database.connectionString : undefined,+ embeddedPostgresDataDir:+ typeof database.embeddedPostgresDataDir === "string"+ ? database.embeddedPostgresDataDir+ : undefined,+ embeddedPostgresPort: asPositiveInt(database.embeddedPostgresPort) ?? undefined,+ pgliteDataDir: typeof database.pgliteDataDir === "string" ? database.pgliteDataDir : undefined,+ pglitePort: asPositiveInt(database.pglitePort) ?? undefined,+ }+ : undefined,+ };+}++export function resolveDatabaseTarget(): ResolvedDatabaseTarget {+ const configPath = resolvePaperclipConfigPath();+ const envPath = resolvePaperclipEnvPath(configPath);+ const envEntries = readEnvEntries(envPath);++ const envUrl = process.env.DATABASE_URL?.trim();+ if (envUrl) {+ return {+ mode: "postgres",+ connectionString: envUrl,+ source: "DATABASE_URL",+ configPath,+ envPath,+ };+ }++ const fileEnvUrl = envEntries.DATABASE_URL?.trim();+ if (fileEnvUrl) {+ return {+ mode: "postgres",+ connectionString: fileEnvUrl,+ source: "paperclip-env",+ configPath,+ envPath,+ };+ }++ const config = readConfig(configPath);+ const connectionString = config?.database?.connectionString?.trim();+ if (config?.database?.mode === "postgres" && connectionString) {+ return {+ mode: "postgres",+ connectionString,+ source: "config.database.connectionString",+ configPath,+ envPath,+ };+ }++ const port = config?.database?.embeddedPostgresPort ?? 54329;+ const dataDir = resolveHomeAwarePath(+ config?.database?.embeddedPostgresDataDir ?? resolveDefaultEmbeddedPostgresDir(),+ );++ return {+ mode: "embedded-postgres",+ dataDir,+ port,+ source: `embedded-postgres@${port}`,+ configPath,+ envPath,+ };+}diff --git a/scripts/dev-runner.mjs b/scripts/dev-runner.mjsindex 43262fd6ff..d4e4c2319d 100644--- a/scripts/dev-runner.mjs+++ b/scripts/dev-runner.mjs@@ -1,5 +1,7 @@#!/usr/bin/env nodeimport { spawn } from "node:child_process";+import { createInterface } from "node:readline/promises";+import { stdin, stdout } from "node:process";const mode = process.argv[2] === "watch" ? "watch" : "dev";const cliArgs = process.argv.slice(3);@@ -43,6 +45,121 @@ if (tailscaleAuth) {}const pnpmBin = process.platform === "win32" ? "pnpm.cmd" : "pnpm";++function formatPendingMigrationSummary(migrations) {+ if (migrations.length === 0) return "none";+ return migrations.length > 3+ ? `${migrations.slice(0, 3).join(", ")} (+${migrations.length - 3} more)`+ : migrations.join(", ");+}++async function runPnpm(args, options = {}) {+ return await new Promise((resolve, reject) => {+ const child = spawn(pnpmBin, args, {+ stdio: options.stdio ?? ["ignore", "pipe", "pipe"],+ env: options.env ?? process.env,+ shell: process.platform === "win32",+ });++ let stdoutBuffer = "";+ let stderrBuffer = "";++ if (child.stdout) {+ child.stdout.on("data", (chunk) => {+ stdoutBuffer += String(chunk);+ });+ }+ if (child.stderr) {+ child.stderr.on("data", (chunk) => {+ stderrBuffer += String(chunk);+ });+ }++ child.on("error", reject);+ child.on("exit", (code, signal) => {+ resolve({+ code: code ?? 0,+ signal,+ stdout: stdoutBuffer,+ stderr: stderrBuffer,+ });+ });+ });+}++async function maybePreflightMigrations() {+ if (mode !== "watch") return;+ if (process.env.PAPERCLIP_MIGRATION_PROMPT === "never") return;++ const status = await runPnpm(+ ["--filter", "@paperclipai/db", "exec", "tsx", "src/migration-status.ts", "--json"],+ { env },+ );+ if (status.code !== 0) {+ process.stderr.write(status.stderr || status.stdout);+ process.exit(status.code);+ }++ let payload;+ try {+ payload = JSON.parse(status.stdout.trim());+ } catch (error) {+ process.stderr.write(status.stderr || status.stdout);+ throw error;+ }++ if (payload.status !== "needsMigrations" || payload.pendingMigrations.length === 0) {+ return;+ }++ const autoApply = process.env.PAPERCLIP_MIGRATION_AUTO_APPLY === "true";+ let shouldApply = autoApply;++ if (!autoApply) {+ if (!stdin.isTTY || !stdout.isTTY) {+ shouldApply = true;+ } else {+ const prompt = createInterface({ input: stdin, output: stdout });+ try {+ const answer = (+ await prompt.question(+ `Apply pending migrations (${formatPendingMigrationSummary(payload.pendingMigrations)}) now? (y/N): `,+ )+ )+ .trim()+ .toLowerCase();+ shouldApply = answer === "y" || answer === "yes";+ } finally {+ prompt.close();+ }+ }+ }++ if (!shouldApply) return;++ const migrate = spawn(pnpmBin, ["db:migrate"], {+ stdio: "inherit",+ env,+ shell: process.platform === "win32",+ });+ const exit = await new Promise((resolve) => {+ migrate.on("exit", (code, signal) => resolve({ code: code ?? 0, signal }));+ });+ if (exit.signal) {+ process.kill(process.pid, exit.signal);+ return;+ }+ if (exit.code !== 0) {+ process.exit(exit.code);+ }+}++await maybePreflightMigrations();++if (mode === "watch") {+ env.PAPERCLIP_MIGRATION_PROMPT = "never";+}+const serverScript = mode === "watch" ? "dev:watch" : "dev";const child = spawn(pnpmBin,@@ -57,4 +174,3 @@ child.on("exit", (code, signal) => {}process.exit(code ?? 0);});-