@hiai-gg/hiai-docs 0.0.1

package/packages/db/src/migrations/meta/_journal.json

@@ -0,0 +1,27 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1780763526911,
+      "tag": "0000_nice_bedlam",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1781110876591,
+      "tag": "0001_w2_3_test",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1781197276591,
+      "tag": "0002_rename_content_json",
+      "breakpoints": true
+    }
+  ]
+}

package/packages/db/src/schema.ts

@@ -0,0 +1,378 @@
+import { pgTable, uuid, text, timestamp, bigint, jsonb, index, uniqueIndex, customType, boolean, type AnyPgColumn } from "drizzle-orm/pg-core";
+
+// pgvector vector type — maps to PostgreSQL vector(n) column
+const vector = customType<{ data: number[] }>({
+  dataType() {
+    return "vector(1024)";
+  },
+  toDriver(value: number[]) {
+    return JSON.stringify(value);
+  },
+  fromDriver(value: unknown) {
+    if (typeof value === "string") return JSON.parse(value) as number[];
+    return value as number[];
+  },
+});
+
+// PostgreSQL tsvector type — used for documents.search_vector full-text search
+const tsvector = customType<{ data: string }>({
+  dataType() {
+    return "tsvector";
+  },
+});
+
+import { relations, sql } from "drizzle-orm";
+
+// ============================================
+// users — managed by Better Auth
+// ============================================
+export const users = pgTable("users", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  email: text("email").notNull().unique(),
+  name: text("name"),
+  emailVerified: boolean("email_verified").default(false),
+  image: text("image"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// ============================================
+// sessions — managed by Better Auth
+// ============================================
+export const sessions = pgTable("sessions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  token: text("token").notNull().unique(),
+  expiresAt: timestamp("expires_at").notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => [
+  index("sessions_user_id_idx").on(table.userId),
+]);
+
+// ============================================
+// accounts — managed by Better Auth
+// ============================================
+export const accounts = pgTable("accounts", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => [
+  index("accounts_user_id_idx").on(table.userId),
+  uniqueIndex("accounts_provider_account_idx").on(table.providerId, table.accountId),
+]);
+
+// ============================================
+// verifications — managed by Better Auth
+// ============================================
+export const verifications = pgTable("verifications", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => [
+  index("verifications_identifier_idx").on(table.identifier),
+]);
+
+// ============================================
+// folders — hierarchical folder structure
+// ============================================
+export const folders = pgTable(
+  "folders",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    ownerId: uuid("owner_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    parentId: uuid("parent_id").references((): AnyPgColumn => folders.id, {
+      onDelete: "set null",
+    }),
+    name: text("name").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("folders_owner_id_idx").on(table.ownerId),
+    index("folders_parent_id_idx").on(table.parentId),
+  ]
+);
+
+// Self-referencing for parent folder
+export const folderRelations = relations(folders, ({ one, many }) => ({
+  owner: one(users, { fields: [folders.ownerId], references: [users.id] }),
+  parent: one(folders, {
+    fields: [folders.parentId],
+    references: [folders.id],
+    relationName: "folderParent",
+  }),
+  children: many(folders, { relationName: "folderParent" }),
+  documents: many(documents),
+}));
+
+// ============================================
+// documents — core content
+// ============================================
+export const documents = pgTable(
+  "documents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    ownerId: uuid("owner_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    folderId: uuid("folder_id").references(() => folders.id, {
+      onDelete: "set null",
+    }),
+    title: text("title").notNull().default("Untitled"),
+    content: text("content").default(""),
+    contentJson: jsonb("content_json"),
+    metadata: jsonb("metadata"),
+    searchVector: tsvector("search_vector").generatedAlwaysAs(
+      sql`to_tsvector('english', COALESCE(title, '') || ' ' || COALESCE(content, ''))`
+    ),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("documents_owner_id_idx").on(table.ownerId),
+    index("documents_folder_id_idx").on(table.folderId),
+    index("documents_created_at_idx").on(table.createdAt),
+    index("idx_documents_search_vector").using("gin", table.searchVector),
+    index("idx_documents_title_trgm").using(
+      "gin",
+      sql`${table.title} gin_trgm_ops`
+    ),
+  ]
+);
+
+export const documentRelations = relations(documents, ({ one, many }) => ({
+  owner: one(users, { fields: [documents.ownerId], references: [users.id] }),
+  folder: one(folders, {
+    fields: [documents.folderId],
+    references: [folders.id],
+  }),
+  tags: many(documentTags),
+  attachments: many(attachments),
+  versions: many(versions),
+}));
+
+// ============================================
+// tags — document tags
+// ============================================
+export const tags = pgTable(
+  "tags",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    ownerId: uuid("owner_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    color: text("color"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("tags_owner_id_idx").on(table.ownerId),
+    uniqueIndex("tags_owner_name_idx").on(table.ownerId, table.name),
+  ]
+);
+
+export const tagRelations = relations(tags, ({ many }) => ({
+  documents: many(documentTags),
+}));
+
+// ============================================
+// document_tags — many-to-many
+// ============================================
+export const documentTags = pgTable(
+  "document_tags",
+  {
+    documentId: uuid("document_id")
+      .notNull()
+      .references(() => documents.id, { onDelete: "cascade" }),
+    tagId: uuid("tag_id")
+      .notNull()
+      .references(() => tags.id, { onDelete: "cascade" }),
+  },
+  (table) => [
+    uniqueIndex("document_tags_unique_idx").on(table.documentId, table.tagId),
+  ]
+);
+
+export const documentTagRelations = relations(documentTags, ({ one }) => ({
+  document: one(documents, {
+    fields: [documentTags.documentId],
+    references: [documents.id],
+  }),
+  tag: one(tags, { fields: [documentTags.tagId], references: [tags.id] }),
+}));
+
+// ============================================
+// share_links — sharing tokens
+// ============================================
+export const shareLinks = pgTable(
+  "share_links",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    documentId: uuid("document_id").references(() => documents.id, {
+      onDelete: "cascade",
+    }),
+    folderId: uuid("folder_id").references(() => folders.id, {
+      onDelete: "cascade",
+    }),
+    token: text("token").notNull().unique(),
+    passwordHash: text("password_hash"),
+    expiresAt: timestamp("expires_at"),
+    createdBy: uuid("created_by")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("share_links_token_idx").on(table.token),
+    index("share_links_document_id_idx").on(table.documentId),
+    index("share_links_folder_id_idx").on(table.folderId),
+  ]
+);
+
+export const shareLinkRelations = relations(shareLinks, ({ one, many }) => ({
+  document: one(documents, {
+    fields: [shareLinks.documentId],
+    references: [documents.id],
+  }),
+  folder: one(folders, {
+    fields: [shareLinks.folderId],
+    references: [folders.id],
+  }),
+  creator: one(users, {
+    fields: [shareLinks.createdBy],
+    references: [users.id],
+  }),
+  guestAccess: many(guestAccess),
+}));
+
+// ============================================
+// guest_access — guest email grants
+// ============================================
+export const guestAccess = pgTable(
+  "guest_access",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    shareLinkId: uuid("share_link_id")
+      .notNull()
+      .references(() => shareLinks.id, { onDelete: "cascade" }),
+    guestEmail: text("guest_email").notNull(),
+    grantedAt: timestamp("granted_at").defaultNow().notNull(),
+  },
+  (table) => [index("guest_access_share_link_idx").on(table.shareLinkId)]
+);
+
+export const guestAccessRelations = relations(guestAccess, ({ one }) => ({
+  shareLink: one(shareLinks, {
+    fields: [guestAccess.shareLinkId],
+    references: [shareLinks.id],
+  }),
+}));
+
+// ============================================
+// attachments — file uploads (MinIO)
+// ============================================
+export const attachments = pgTable(
+  "attachments",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    documentId: uuid("document_id")
+      .notNull()
+      .references(() => documents.id, { onDelete: "cascade" }),
+    filename: text("filename").notNull(),
+    mimeType: text("mime_type").notNull(),
+    size: bigint("size", { mode: "number" }).notNull(),
+    minioKey: text("minio_key").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [index("attachments_document_id_idx").on(table.documentId)]
+);
+
+export const attachmentRelations = relations(attachments, ({ one }) => ({
+  document: one(documents, {
+    fields: [attachments.documentId],
+    references: [documents.id],
+  }),
+}));
+
+// ============================================
+// versions — document version history
+// ============================================
+export const versions = pgTable(
+  "versions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    documentId: uuid("document_id")
+      .notNull()
+      .references(() => documents.id, { onDelete: "cascade" }),
+    content: text("content").notNull(),
+    contentJson: jsonb("content_json"),
+    createdBy: uuid("created_by")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("versions_document_id_idx").on(table.documentId),
+    index("versions_created_at_idx").on(table.createdAt),
+  ]
+);
+
+// ============================================
+// document_embeddings — multi-chunk pgvector storage
+// ============================================
+export const documentEmbeddings = pgTable(
+  "document_embeddings",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    documentId: uuid("document_id")
+      .notNull()
+      .references(() => documents.id, { onDelete: "cascade" }),
+    chunkIndex: bigint("chunk_index", { mode: "number" }).notNull(),
+    chunkText: text("chunk_text").notNull(),
+    embedding: vector("embedding"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("document_embeddings_doc_id_idx").on(table.documentId),
+    uniqueIndex("document_embeddings_doc_chunk_idx").on(table.documentId, table.chunkIndex),
+    index("idx_document_embeddings_hnsw").using(
+      "hnsw",
+      sql`${table.embedding} vector_cosine_ops`
+    ),
+  ]
+);
+
+export const documentEmbeddingRelations = relations(documentEmbeddings, ({ one }) => ({
+  document: one(documents, {
+    fields: [documentEmbeddings.documentId],
+    references: [documents.id],
+  }),
+}));
+
+export const versionRelations = relations(versions, ({ one }) => ({
+  document: one(documents, {
+    fields: [versions.documentId],
+    references: [documents.id],
+  }),
+  creator: one(users, {
+    fields: [versions.createdBy],
+    references: [users.id],
+  }),
+}));

package/packages/db/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/scripts/export-openapi.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env bun
+/**
+ * Export OpenAPI spec from the running hiai-docs API.
+ * Usage: bun run scripts/export-openapi.ts
+ *
+ * The API server must be running (default: http://localhost:50700).
+ * Output: docs/openapi.json
+ */
+
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+const API_URL = process.env.API_URL ?? "http://localhost:50700";
+const OUTPUT_PATH = join(import.meta.dir, "..", "docs", "openapi.json");
+
+async function exportSpec() {
+  console.log(`Fetching OpenAPI spec from ${API_URL}/api/docs/json ...`);
+
+  const response = await fetch(`${API_URL}/api/docs/json`);
+  if (!response.ok) {
+    console.error(`Failed to fetch spec: ${response.status} ${response.statusText}`);
+    process.exit(1);
+  }
+
+  const spec = await response.json();
+
+  mkdirSync(join(import.meta.dir, "..", "docs"), { recursive: true });
+  writeFileSync(OUTPUT_PATH, JSON.stringify(spec, null, 2) + "\n");
+
+  console.log(`OpenAPI spec exported to ${OUTPUT_PATH}`);
+  console.log(`Endpoints: ${Object.keys((spec as Record<string, unknown>).paths ?? {}).length}`);
+}
+
+exportSpec().catch((err) => {
+  console.error("Export failed:", err);
+  process.exit(1);
+});

package/scripts/health-check.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# hiai-docs health-check script
+# Usage: ./scripts/health-check.sh
+#
+# Checks liveness/readiness of every service in the hiai-docs stack.
+# Exits 0 only if all checks pass; exits 1 if any check fails.
+#
+# Environment overrides (all optional):
+#   API_PORT    default 50700
+#   DB_PORT     default 5433
+#   DB_USER     default aiuser
+#   DB_NAME     default hiai_docs
+#   DB_HOST     default localhost
+#   REDIS_PORT  default 6380  (matches REDIS_URL in .env.example)
+#   OLLAMA_URL  default http://localhost:11434
+#   MINIO_PORT  default 9000
+#   MINIO_HEALTH_PATH  default /minio/health/live
+#
+# Example:
+#   ./scripts/health-check.sh
+#   REDIS_PORT=6380 API_PORT=50700 ./scripts/health-check.sh
+
+set -euo pipefail
+
+API_PORT="${API_PORT:-50700}"
+DB_HOST="${DB_HOST:-localhost}"
+DB_PORT="${DB_PORT:-5433}"
+DB_USER="${DB_USER:-aiuser}"
+DB_NAME="${DB_NAME:-hiai_docs}"
+REDIS_PORT="${REDIS_PORT:-6380}"
+OLLAMA_URL="${OLLAMA_URL:-http://localhost:11434}"
+MINIO_PORT="${MINIO_PORT:-9000}"
+MINIO_HEALTH_PATH="${MINIO_HEALTH_PATH:-/minio/health/live}"
+
+fail=0
+
+check() {
+  local name="$1"
+  local cmd="$2"
+  if eval "$cmd" >/dev/null 2>&1; then
+    echo "  ✅ $name"
+  else
+    echo "  ❌ $name"
+    fail=1
+  fi
+}
+
+echo "hiai-docs Health Checks"
+echo "======================="
+echo "API:        http://localhost:${API_PORT}/api/health"
+echo "PostgreSQL: ${DB_USER}@${DB_HOST}:${DB_PORT}/${DB_NAME}"
+echo "Redis:      localhost:${REDIS_PORT}"
+echo "Ollama:     ${OLLAMA_URL}"
+echo "MinIO:      http://localhost:${MINIO_PORT}${MINIO_HEALTH_PATH}"
+echo ""
+
+check "API"        "curl -fsS http://localhost:${API_PORT}/api/health"
+check "PostgreSQL" "psql -h ${DB_HOST} -p ${DB_PORT} -U ${DB_USER} -d ${DB_NAME} -c 'SELECT 1'"
+check "Redis"      "redis-cli -p ${REDIS_PORT} ping"
+check "Ollama"     "curl -fsS ${OLLAMA_URL}/api/tags"
+check "MinIO"      "curl -fsS http://localhost:${MINIO_PORT}${MINIO_HEALTH_PATH}"
+
+echo ""
+if [ "$fail" -eq 0 ]; then
+  echo "✅ All services healthy"
+  exit 0
+else
+  echo "❌ One or more services failed"
+  echo ""
+  echo "Troubleshooting:"
+  echo "  - Start the stack:  docker compose up -d"
+  echo "  - Tail logs:        docker compose logs -f <service>"
+  echo "  - Per-service healthchecks are defined in docker-compose.yml"
+  exit 1
+fi

package/scripts/migrate.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+# hiai-docs database migration script
+# Usage: ./scripts/migrate.sh [--yes] [--generate-only]
+#
+# Runs the Drizzle workflow against the configured database:
+#   1. bun install                 (if node_modules missing)
+#   2. db:generate                 (regenerate SQL from packages/db/src/schema.ts)
+#   3. db:push                     (apply schema to DATABASE_URL)
+#
+# Flags:
+#   --yes           skip the "are you sure?" confirmation prompt
+#   --generate-only run db:generate only, skip the actual db:push
+#   --help          show this help and exit
+#
+# Environment:
+#   DB_HOST / DB_PORT / DB_USER / DB_NAME / DB_PASSWORD  override .env
+#   DATABASE_URL    full connection string (takes precedence if set)
+#
+# Example:
+#   ./scripts/migrate.sh
+#   ./scripts/migrate.sh --yes
+#   ./scripts/migrate.sh --generate-only
+
+set -euo pipefail
+
+# --- Argument parsing ---
+SKIP_CONFIRM=0
+GENERATE_ONLY=0
+for arg in "$@"; do
+  case "$arg" in
+    --yes)            SKIP_CONFIRM=1 ;;
+    --generate-only)  GENERATE_ONLY=1 ;;
+    --help|-h)
+      sed -n '2,18p' "$0" | sed 's/^# \?//'
+      exit 0
+      ;;
+    *)
+      echo "❌ Unknown argument: $arg"
+      echo "   Run with --help for usage."
+      exit 2
+      ;;
+  esac
+done
+
+# --- Sanity checks ---
+if [ ! -f "package.json" ] || [ ! -d "packages/db" ]; then
+  echo "❌ package.json or packages/db not found."
+  echo "   Run this script from the hiai-docs project root."
+  exit 1
+fi
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "❌ bun is required but not installed."
+  echo "   Install: https://bun.sh/docs/installation"
+  exit 1
+fi
+
+# Load .env if it exists (so DATABASE_URL / DB_* are available)
+if [ -f ".env" ] && [ -z "${DATABASE_URL:-}" ]; then
+  set -a
+  # shellcheck disable=SC1091
+  . ./.env
+  set +a
+fi
+
+if [ -z "${DATABASE_URL:-}" ]; then
+  echo "❌ DATABASE_URL is not set."
+  echo "   Either set it in .env, or export DATABASE_URL before running this script."
+  exit 1
+fi
+
+# --- Pre-flight: confirm the database is reachable ---
+echo "==> hiai-docs Migration"
+echo "    DATABASE_URL=${DATABASE_URL}"
+echo ""
+
+if command -v psql >/dev/null 2>&1; then
+  if ! psql "${DATABASE_URL}" -c "SELECT 1" >/dev/null 2>&1; then
+    echo "❌ Cannot connect to database at ${DATABASE_URL}."
+    echo "   Start the stack with: docker compose up -d postgres"
+    exit 1
+  fi
+  echo "    ✅ Database reachable"
+else
+  echo "    ⚠️  psql not found — skipping connectivity check (db:push will fail loudly if unreachable)"
+fi
+
+# --- Confirm destructive intent (db:push drops + recreates tables) ---
+if [ "$GENERATE_ONLY" -eq 0 ] && [ "$SKIP_CONFIRM" -eq 0 ]; then
+  echo ""
+  echo "⚠️  About to push schema to ${DATABASE_URL}."
+  echo "   db:push will ALTER tables to match the Drizzle schema (destructive on type changes)."
+  printf "   Continue? [y/N] "
+  read -r reply
+  case "$reply" in
+    y|Y|yes|YES) ;;
+    *)
+      echo "Aborted."
+      exit 0
+      ;;
+  esac
+fi
+
+echo ""
+
+# --- Install deps if needed ---
+if [ ! -d "node_modules" ] || [ ! -d "packages/db/node_modules" ]; then
+  echo "==> Installing dependencies..."
+  bun install
+else
+  echo "==> Dependencies already installed (skipping bun install)"
+fi
+
+# --- Regenerate migration SQL from schema ---
+echo ""
+echo "==> Regenerating SQL migrations from packages/db/src/schema.ts..."
+cd packages/db
+bun run db:generate
+cd ../..
+
+# --- Push to database (unless --generate-only) ---
+if [ "$GENERATE_ONLY" -eq 1 ]; then
+  echo ""
+  echo "✅ Migrations regenerated (--generate-only; db:push skipped)"
+  exit 0
+fi
+
+echo ""
+echo "==> Pushing schema to ${DATABASE_URL}..."
+cd packages/db
+bun run db:push
+cd ../..
+
+echo ""
+echo "✅ Migration complete"

package/scripts/prework_backup.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# hiai-docs pre-work backup script
+# Usage: ./scripts/prework_backup.sh [project_name]
+
+set -euo pipefail
+
+PROJECT_NAME="${1:-hiai-docs}"
+BACKUP_DIR="/mnt/ai_data/backup/${PROJECT_NAME}/$(date +%Y-%m-%d_%H%M%S)"
+
+mkdir -p "$BACKUP_DIR"
+
+echo "Creating backup snapshot for ${PROJECT_NAME}..."
+
+# Backup database if running
+if docker compose ps postgres 2>/dev/null | grep -q "Up"; then
+  echo "Backing up PostgreSQL..."
+  docker compose exec -T postgres pg_dump -U aiuser hiai_docs > "${BACKUP_DIR}/database.sql" 2>/dev/null || echo "DB backup skipped (not running or not accessible)"
+fi
+
+# Backup .env
+if [ -f ".env" ]; then
+  cp .env "${BACKUP_DIR}/.env.bak"
+fi
+
+echo "Backup created at: ${BACKUP_DIR}"