offwatch 0.5.12 → 0.5.13

package/src/commands/routines.ts

@@ -1,352 +0,0 @@
-import fs from "node:fs";
-import net from "node:net";
-import path from "node:path";
-import { Command } from "commander";
-import pc from "picocolors";
-import {
-  applyPendingMigrations,
-  createDb,
-  createEmbeddedPostgresLogBuffer,
-  ensurePostgresDatabase,
-  formatEmbeddedPostgresError,
-  routines,
-} from "@paperclipai/db";
-import { eq, inArray } from "drizzle-orm";
-import { loadPaperclipEnvFile } from "../config/env.js";
-import { readConfig, resolveConfigPath } from "../config/store.js";
-
-type RoutinesDisableAllOptions = {
-  config?: string;
-  dataDir?: string;
-  companyId?: string;
-  json?: boolean;
-};
-
-type DisableAllRoutinesResult = {
-  companyId: string;
-  totalRoutines: number;
-  pausedCount: number;
-  alreadyPausedCount: number;
-  archivedCount: number;
-};
-
-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;
-  initdbFlags?: string[];
-  onLog?: (message: unknown) => void;
-  onError?: (message: unknown) => void;
-}) => EmbeddedPostgresInstance;
-
-type EmbeddedPostgresHandle = {
-  port: number;
-  startedByThisProcess: boolean;
-  stop: () => Promise<void>;
-};
-
-type ClosableDb = ReturnType<typeof createDb> & {
-  $client?: {
-    end?: (options?: { timeout?: number }) => Promise<void>;
-  };
-};
-
-function nonEmpty(value: string | null | undefined): string | null {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-
-async function isPortAvailable(port: number): Promise<boolean> {
-  return await new Promise<boolean>((resolve) => {
-    const server = net.createServer();
-    server.unref();
-    server.once("error", () => resolve(false));
-    server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve(true));
-    });
-  });
-}
-
-async function findAvailablePort(preferredPort: number): Promise<number> {
-  let port = Math.max(1, Math.trunc(preferredPort));
-  while (!(await isPortAvailable(port))) {
-    port += 1;
-  }
-  return port;
-}
-
-function readPidFilePort(postmasterPidFile: string): number | null {
-  if (!fs.existsSync(postmasterPidFile)) return null;
-  try {
-    const lines = fs.readFileSync(postmasterPidFile, "utf8").split("\n");
-    const port = Number(lines[3]?.trim());
-    return Number.isInteger(port) && port > 0 ? port : null;
-  } catch {
-    return null;
-  }
-}
-
-function readRunningPostmasterPid(postmasterPidFile: string): number | null {
-  if (!fs.existsSync(postmasterPidFile)) return null;
-  try {
-    const pid = Number(fs.readFileSync(postmasterPidFile, "utf8").split("\n")[0]?.trim());
-    if (!Number.isInteger(pid) || pid <= 0) return null;
-    process.kill(pid, 0);
-    return pid;
-  } catch {
-    return null;
-  }
-}
-
-async function ensureEmbeddedPostgres(dataDir: string, preferredPort: number): Promise<EmbeddedPostgresHandle> {
-  const moduleName = "embedded-postgres";
-  let EmbeddedPostgres: EmbeddedPostgresCtor;
-  try {
-    const mod = await import(moduleName);
-    EmbeddedPostgres = mod.default as EmbeddedPostgresCtor;
-  } catch {
-    throw new Error(
-      "Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again.",
-    );
-  }
-
-  const postmasterPidFile = path.resolve(dataDir, "postmaster.pid");
-  const runningPid = readRunningPostmasterPid(postmasterPidFile);
-  if (runningPid) {
-    return {
-      port: readPidFilePort(postmasterPidFile) ?? preferredPort,
-      startedByThisProcess: false,
-      stop: async () => {},
-    };
-  }
-
-  const port = await findAvailablePort(preferredPort);
-  const logBuffer = createEmbeddedPostgresLogBuffer();
-  const instance = new EmbeddedPostgres({
-    databaseDir: dataDir,
-    user: "paperclip",
-    password: "paperclip",
-    port,
-    persistent: true,
-    initdbFlags: ["--encoding=UTF8", "--locale=C", "--lc-messages=C"],
-    onLog: logBuffer.append,
-    onError: logBuffer.append,
-  });
-
-  if (!fs.existsSync(path.resolve(dataDir, "PG_VERSION"))) {
-    try {
-      await instance.initialise();
-    } catch (error) {
-      throw formatEmbeddedPostgresError(error, {
-        fallbackMessage: `Failed to initialize embedded PostgreSQL cluster in ${dataDir} on port ${port}`,
-        recentLogs: logBuffer.getRecentLogs(),
-      });
-    }
-  }
-
-  if (fs.existsSync(postmasterPidFile)) {
-    fs.rmSync(postmasterPidFile, { force: true });
-  }
-
-  try {
-    await instance.start();
-  } catch (error) {
-    throw formatEmbeddedPostgresError(error, {
-      fallbackMessage: `Failed to start embedded PostgreSQL on port ${port}`,
-      recentLogs: logBuffer.getRecentLogs(),
-    });
-  }
-
-  return {
-    port,
-    startedByThisProcess: true,
-    stop: async () => {
-      await instance.stop();
-    },
-  };
-}
-
-async function closeDb(db: ClosableDb): Promise<void> {
-  await db.$client?.end?.({ timeout: 5 }).catch(() => undefined);
-}
-
-async function openConfiguredDb(configPath: string): Promise<{
-  db: ClosableDb;
-  stop: () => Promise<void>;
-}> {
-  const config = readConfig(configPath);
-  if (!config) {
-    throw new Error(`Config not found at ${configPath}.`);
-  }
-
-  let embeddedHandle: EmbeddedPostgresHandle | null = null;
-  try {
-    if (config.database.mode === "embedded-postgres") {
-      embeddedHandle = await ensureEmbeddedPostgres(
-        config.database.embeddedPostgresDataDir,
-        config.database.embeddedPostgresPort,
-      );
-      const adminConnectionString = `postgres://paperclip:paperclip@127.0.0.1:${embeddedHandle.port}/postgres`;
-      await ensurePostgresDatabase(adminConnectionString, "paperclip");
-      const connectionString = `postgres://paperclip:paperclip@127.0.0.1:${embeddedHandle.port}/paperclip`;
-      await applyPendingMigrations(connectionString);
-      const db = createDb(connectionString) as ClosableDb;
-      return {
-        db,
-        stop: async () => {
-          await closeDb(db);
-          if (embeddedHandle?.startedByThisProcess) {
-            await embeddedHandle.stop().catch(() => undefined);
-          }
-        },
-      };
-    }
-
-    const connectionString = nonEmpty(config.database.connectionString);
-    if (!connectionString) {
-      throw new Error(`Config at ${configPath} does not define a database connection string.`);
-    }
-
-    await applyPendingMigrations(connectionString);
-    const db = createDb(connectionString) as ClosableDb;
-    return {
-      db,
-      stop: async () => {
-        await closeDb(db);
-      },
-    };
-  } catch (error) {
-    if (embeddedHandle?.startedByThisProcess) {
-      await embeddedHandle.stop().catch(() => undefined);
-    }
-    throw error;
-  }
-}
-
-export async function disableAllRoutinesInConfig(
-  options: Pick<RoutinesDisableAllOptions, "config" | "companyId">,
-): Promise<DisableAllRoutinesResult> {
-  const configPath = resolveConfigPath(options.config);
-  loadPaperclipEnvFile(configPath);
-  const companyId =
-    nonEmpty(options.companyId)
-    ?? nonEmpty(process.env.PAPERCLIP_COMPANY_ID)
-    ?? null;
-  if (!companyId) {
-    throw new Error("Company ID is required. Pass --company-id or set PAPERCLIP_COMPANY_ID.");
-  }
-
-  const config = readConfig(configPath);
-  if (!config) {
-    throw new Error(`Config not found at ${configPath}.`);
-  }
-
-  let embeddedHandle: EmbeddedPostgresHandle | null = null;
-  let db: ClosableDb | null = null;
-  try {
-    if (config.database.mode === "embedded-postgres") {
-      embeddedHandle = await ensureEmbeddedPostgres(
-        config.database.embeddedPostgresDataDir,
-        config.database.embeddedPostgresPort,
-      );
-      const adminConnectionString = `postgres://paperclip:paperclip@127.0.0.1:${embeddedHandle.port}/postgres`;
-      await ensurePostgresDatabase(adminConnectionString, "paperclip");
-      const connectionString = `postgres://paperclip:paperclip@127.0.0.1:${embeddedHandle.port}/paperclip`;
-      await applyPendingMigrations(connectionString);
-      db = createDb(connectionString) as ClosableDb;
-    } else {
-      const connectionString = nonEmpty(config.database.connectionString);
-      if (!connectionString) {
-        throw new Error(`Config at ${configPath} does not define a database connection string.`);
-      }
-      await applyPendingMigrations(connectionString);
-      db = createDb(connectionString) as ClosableDb;
-    }
-
-    const existing = await db
-      .select({
-        id: routines.id,
-        status: routines.status,
-      })
-      .from(routines)
-      .where(eq(routines.companyId, companyId));
-
-    const alreadyPausedCount = existing.filter((routine) => routine.status === "paused").length;
-    const archivedCount = existing.filter((routine) => routine.status === "archived").length;
-    const idsToPause = existing
-      .filter((routine) => routine.status !== "paused" && routine.status !== "archived")
-      .map((routine) => routine.id);
-
-    if (idsToPause.length > 0) {
-      await db
-        .update(routines)
-        .set({
-          status: "paused",
-          updatedAt: new Date(),
-        })
-        .where(inArray(routines.id, idsToPause));
-    }
-
-    return {
-      companyId,
-      totalRoutines: existing.length,
-      pausedCount: idsToPause.length,
-      alreadyPausedCount,
-      archivedCount,
-    };
-  } finally {
-    if (db) {
-      await closeDb(db);
-    }
-    if (embeddedHandle?.startedByThisProcess) {
-      await embeddedHandle.stop().catch(() => undefined);
-    }
-  }
-}
-
-export async function disableAllRoutinesCommand(options: RoutinesDisableAllOptions): Promise<void> {
-  const result = await disableAllRoutinesInConfig(options);
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-
-  if (result.totalRoutines === 0) {
-    console.log(pc.dim(`No routines found for company ${result.companyId}.`));
-    return;
-  }
-
-  console.log(
-    `Paused ${result.pausedCount} routine(s) for company ${result.companyId} ` +
-      `(${result.alreadyPausedCount} already paused, ${result.archivedCount} archived).`,
-  );
-}
-
-export function registerRoutineCommands(program: Command): void {
-  const routinesCommand = program.command("routines").description("Local routine maintenance commands");
-
-  routinesCommand
-    .command("disable-all")
-    .description("Pause all non-archived routines in the configured local instance for one company")
-    .option("-c, --config <path>", "Path to config file")
-    .option("-d, --data-dir <path>", "Paperclip data directory root (isolates state from ~/.paperclip)")
-    .option("-C, --company-id <id>", "Company ID")
-    .option("--json", "Output raw JSON")
-    .action(async (opts: RoutinesDisableAllOptions) => {
-      try {
-        await disableAllRoutinesCommand(opts);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(pc.red(message));
-        process.exit(1);
-      }
-    });
-}

package/src/commands/run.ts

@@ -1,216 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import { bootstrapCeoInvite } from "./auth-bootstrap-ceo.js";
-import { onboard } from "./onboard.js";
-import { doctor } from "./doctor.js";
-import { loadPaperclipEnvFile } from "../config/env.js";
-import { configExists, resolveConfigPath } from "../config/store.js";
-import type { PaperclipConfig } from "../config/schema.js";
-import { readConfig } from "../config/store.js";
-import {
-  describeLocalInstancePaths,
-  resolvePaperclipHomeDir,
-  resolvePaperclipInstanceId,
-} from "../config/home.js";
-
-interface RunOptions {
-  config?: string;
-  instance?: string;
-  repair?: boolean;
-  yes?: boolean;
-  bind?: "loopback" | "lan" | "tailnet";
-}
-
-interface StartedServer {
-  apiUrl: string;
-  databaseUrl: string;
-  host: string;
-  listenPort: number;
-}
-
-export async function runCommand(opts: RunOptions): Promise<void> {
-  const instanceId = resolvePaperclipInstanceId(opts.instance);
-  process.env.PAPERCLIP_INSTANCE_ID = instanceId;
-
-  const homeDir = resolvePaperclipHomeDir();
-  fs.mkdirSync(homeDir, { recursive: true });
-
-  const paths = describeLocalInstancePaths(instanceId);
-  fs.mkdirSync(paths.instanceRoot, { recursive: true });
-
-  const configPath = resolveConfigPath(opts.config);
-  process.env.PAPERCLIP_CONFIG = configPath;
-  loadPaperclipEnvFile(configPath);
-
-  p.intro(pc.bgCyan(pc.black(" paperclipai run ")));
-  p.log.message(pc.dim(`Home: ${paths.homeDir}`));
-  p.log.message(pc.dim(`Instance: ${paths.instanceId}`));
-  p.log.message(pc.dim(`Config: ${configPath}`));
-
-  if (!configExists(configPath)) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-      p.log.error("No config found and terminal is non-interactive.");
-      p.log.message(`Run ${pc.cyan("paperclipai onboard")} once, then retry ${pc.cyan("paperclipai run")}.`);
-      process.exit(1);
-    }
-
-    p.log.step("No config found. Starting onboarding...");
-    await onboard({ config: configPath, invokedByRun: true, bind: opts.bind });
-  }
-
-  p.log.step("Running doctor checks...");
-  const summary = await doctor({
-    config: configPath,
-    repair: opts.repair ?? true,
-    yes: opts.yes ?? true,
-  });
-
-  if (summary.failed > 0) {
-    p.log.error("Doctor found blocking issues. Not starting server.");
-    process.exit(1);
-  }
-
-  const config = readConfig(configPath);
-  if (!config) {
-    p.log.error(`No config found at ${configPath}.`);
-    process.exit(1);
-  }
-
-  p.log.step("Starting Paperclip server...");
-  const startedServer = await importServerEntry();
-
-  if (shouldGenerateBootstrapInviteAfterStart(config)) {
-    p.log.step("Generating bootstrap CEO invite");
-    await bootstrapCeoInvite({
-      config: configPath,
-      dbUrl: startedServer.databaseUrl,
-      baseUrl: resolveBootstrapInviteBaseUrl(config, startedServer),
-    });
-  }
-}
-
-function resolveBootstrapInviteBaseUrl(
-  config: PaperclipConfig,
-  startedServer: StartedServer,
-): string {
-  const explicitBaseUrl =
-    process.env.PAPERCLIP_PUBLIC_URL ??
-    process.env.PAPERCLIP_AUTH_PUBLIC_BASE_URL ??
-    process.env.BETTER_AUTH_URL ??
-    process.env.BETTER_AUTH_BASE_URL ??
-    (config.auth.baseUrlMode === "explicit" ? config.auth.publicBaseUrl : undefined);
-
-  if (typeof explicitBaseUrl === "string" && explicitBaseUrl.trim().length > 0) {
-    return explicitBaseUrl.trim().replace(/\/+$/, "");
-  }
-
-  return startedServer.apiUrl.replace(/\/api$/, "");
-}
-
-function formatError(err: unknown): string {
-  if (err instanceof Error) {
-    if (err.message && err.message.trim().length > 0) return err.message;
-    return err.name;
-  }
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}
-
-function isModuleNotFoundError(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
-  const code = (err as { code?: unknown }).code;
-  if (code === "ERR_MODULE_NOT_FOUND") return true;
-  return err.message.includes("Cannot find module");
-}
-
-function getMissingModuleSpecifier(err: unknown): string | null {
-  if (!(err instanceof Error)) return null;
-  const packageMatch = err.message.match(/Cannot find package '([^']+)' imported from/);
-  if (packageMatch?.[1]) return packageMatch[1];
-  const moduleMatch = err.message.match(/Cannot find module '([^']+)'/);
-  if (moduleMatch?.[1]) return moduleMatch[1];
-  return null;
-}
-
-function maybeEnableUiDevMiddleware(entrypoint: string): void {
-  if (process.env.PAPERCLIP_UI_DEV_MIDDLEWARE !== undefined) return;
-  const normalized = entrypoint.replaceAll("\\", "/");
-  if (normalized.endsWith("/server/src/index.ts") || normalized.endsWith("@paperclipai/server/src/index.ts")) {
-    process.env.PAPERCLIP_UI_DEV_MIDDLEWARE = "true";
-  }
-}
-
-function ensureDevWorkspaceBuildDeps(projectRoot: string): void {
-  const buildScript = path.resolve(projectRoot, "scripts/ensure-plugin-build-deps.mjs");
-  if (!fs.existsSync(buildScript)) return;
-
-  const result = spawnSync(process.execPath, [buildScript], {
-    cwd: projectRoot,
-    stdio: "inherit",
-    timeout: 120_000,
-  });
-
-  if (result.error) {
-    throw new Error(
-      `Failed to prepare workspace build artifacts before starting the Paperclip dev server.\n${formatError(result.error)}`,
-    );
-  }
-
-  if ((result.status ?? 1) !== 0) {
-    throw new Error(
-      "Failed to prepare workspace build artifacts before starting the Paperclip dev server.",
-    );
-  }
-}
-
-async function importServerEntry(): Promise<StartedServer> {
-  // Dev mode: try local workspace path (monorepo with tsx)
-  const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
-  const devEntry = path.resolve(projectRoot, "server/src/index.ts");
-  if (fs.existsSync(devEntry)) {
-    ensureDevWorkspaceBuildDeps(projectRoot);
-    maybeEnableUiDevMiddleware(devEntry);
-    const mod = await import(pathToFileURL(devEntry).href);
-    return await startServerFromModule(mod, devEntry);
-  }
-
-  // Production mode: import the published @paperclipai/server package
-  try {
-    const mod = await import("@paperclipai/server");
-    return await startServerFromModule(mod, "@paperclipai/server");
-  } catch (err) {
-    const missingSpecifier = getMissingModuleSpecifier(err);
-    const missingServerEntrypoint = !missingSpecifier || missingSpecifier === "@paperclipai/server";
-    if (isModuleNotFoundError(err) && missingServerEntrypoint) {
-      throw new Error(
-        `Could not locate a Paperclip server entrypoint.\n` +
-          `Tried: ${devEntry}, @paperclipai/server\n` +
-          `${formatError(err)}`,
-      );
-    }
-    throw new Error(
-      `Paperclip server failed to start.\n` +
-        `${formatError(err)}`,
-    );
-  }
-}
-
-function shouldGenerateBootstrapInviteAfterStart(config: PaperclipConfig): boolean {
-  return config.server.deploymentMode === "authenticated" && config.database.mode === "embedded-postgres";
-}
-
-async function startServerFromModule(mod: unknown, label: string): Promise<StartedServer> {
-  const startServer = (mod as { startServer?: () => Promise<StartedServer> }).startServer;
-  if (typeof startServer !== "function") {
-    throw new Error(`Paperclip server entrypoint did not export startServer(): ${label}`);
-  }
-  return await startServer();
-}