deploy.sh 2.0.0 → 3.0.0

package/server/store.ts

@@ -0,0 +1,398 @@
+import { mkdirSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { randomBytes, createHash } from 'node:crypto';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { eq } from 'drizzle-orm';
+import { users, deployments, history, requestLogs, resourceMetrics } from './schema.ts';
+import type { RawContainerStats } from './docker.ts';
+
+const DATA_DIR = resolve(process.cwd(), '.deploy-data');
+const DB_FILE = resolve(DATA_DIR, 'deploy.db');
+const UPLOADS_DIR = resolve(DATA_DIR, 'uploads');
+
+let _sqlite: InstanceType<typeof Database> | null = null;
+let _db: ReturnType<typeof drizzle> | null = null;
+
+function getDb() {
+  if (_db) return _db;
+
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+  if (!existsSync(UPLOADS_DIR)) mkdirSync(UPLOADS_DIR, { recursive: true });
+
+  _sqlite = new Database(DB_FILE);
+  _sqlite.pragma('journal_mode = WAL');
+
+  _sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      username TEXT PRIMARY KEY,
+      password TEXT NOT NULL,
+      token TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS deployments (
+      name TEXT PRIMARY KEY,
+      type TEXT,
+      username TEXT NOT NULL,
+      port INTEGER,
+      container_id TEXT,
+      container_name TEXT,
+      directory TEXT,
+      created_at TEXT,
+      updated_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      deployment_name TEXT NOT NULL,
+      action TEXT NOT NULL,
+      username TEXT,
+      type TEXT,
+      port INTEGER,
+      container_id TEXT,
+      timestamp TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS request_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      deployment_name TEXT NOT NULL,
+      method TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status INTEGER NOT NULL,
+      duration INTEGER NOT NULL,
+      timestamp INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_request_logs_deployment
+      ON request_logs(deployment_name);
+    CREATE INDEX IF NOT EXISTS idx_request_logs_timestamp
+      ON request_logs(deployment_name, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_history_deployment
+      ON history(deployment_name);
+    CREATE INDEX IF NOT EXISTS idx_deployments_username
+      ON deployments(username);
+    CREATE TABLE IF NOT EXISTS resource_metrics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      deployment_name TEXT NOT NULL,
+      cpu_percent REAL NOT NULL,
+      mem_usage_bytes INTEGER NOT NULL,
+      mem_limit_bytes INTEGER NOT NULL,
+      mem_percent REAL NOT NULL,
+      net_rx_bytes INTEGER NOT NULL,
+      net_tx_bytes INTEGER NOT NULL,
+      block_read_bytes INTEGER NOT NULL,
+      block_write_bytes INTEGER NOT NULL,
+      pids INTEGER NOT NULL,
+      timestamp INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_resource_metrics_deployment
+      ON resource_metrics(deployment_name);
+    CREATE INDEX IF NOT EXISTS idx_resource_metrics_timestamp
+      ON resource_metrics(deployment_name, timestamp);
+  `);
+
+  _db = drizzle(_sqlite);
+  return _db;
+}
+
+export function _resetDb() {
+  if (_sqlite) _sqlite.close();
+  _sqlite = null;
+  _db = null;
+}
+
+export function getUploadsDir() {
+  return UPLOADS_DIR;
+}
+
+function hashPassword(password: string) {
+  return createHash('sha256').update(password).digest('hex');
+}
+
+function generateToken() {
+  return randomBytes(32).toString('hex');
+}
+
+// ── Users ───────────────────────────────────────────────────────────────────
+
+export function registerUser(username: string, password: string) {
+  const db = getDb();
+  const existing = db.select().from(users).where(eq(users.username, username)).get();
+  if (existing) {
+    return { error: 'User already exists' as const, status: 409 as const };
+  }
+  const token = generateToken();
+  db.insert(users)
+    .values({
+      username,
+      password: hashPassword(password),
+      token,
+      createdAt: new Date().toISOString(),
+    })
+    .run();
+  return { token };
+}
+
+export function loginUser(username: string, password: string) {
+  const db = getDb();
+  const user = db.select().from(users).where(eq(users.username, username)).get();
+  if (!user || user.password !== hashPassword(password)) {
+    return { error: 'Invalid credentials' as const, status: 401 as const };
+  }
+  const token = generateToken();
+  db.update(users).set({ token }).where(eq(users.username, username)).run();
+  return { token };
+}
+
+export function authenticate(
+  username: string | null | undefined,
+  token: string | null | undefined,
+) {
+  if (!username || !token) return false;
+  const db = getDb();
+  const user = db.select().from(users).where(eq(users.username, username)).get();
+  return user != null && user.token === token;
+}
+
+export function logoutUser(username: string) {
+  const db = getDb();
+  db.update(users).set({ token: null }).where(eq(users.username, username)).run();
+}
+
+export function getUser(username: string) {
+  const db = getDb();
+  const user = db
+    .select({ username: users.username, createdAt: users.createdAt })
+    .from(users)
+    .where(eq(users.username, username))
+    .get();
+  return user || null;
+}
+
+// ── Deployments ─────────────────────────────────────────────────────────────
+
+interface DeploymentInput {
+  name: string;
+  type?: string;
+  username: string;
+  port?: number;
+  containerId?: string;
+  containerName?: string;
+  directory?: string;
+  createdAt?: string;
+}
+
+export function saveDeployment(deployment: DeploymentInput) {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.insert(deployments)
+    .values({
+      name: deployment.name,
+      type: deployment.type || null,
+      username: deployment.username,
+      port: deployment.port || null,
+      containerId: deployment.containerId || null,
+      containerName: deployment.containerName || null,
+      directory: deployment.directory || null,
+      createdAt: deployment.createdAt || now,
+      updatedAt: now,
+    })
+    .onConflictDoUpdate({
+      target: deployments.name,
+      set: {
+        type: deployment.type || null,
+        username: deployment.username,
+        port: deployment.port || null,
+        containerId: deployment.containerId || null,
+        containerName: deployment.containerName || null,
+        directory: deployment.directory || null,
+        updatedAt: now,
+      },
+    })
+    .run();
+}
+
+export function getDeployment(name: string) {
+  const db = getDb();
+  return db.select().from(deployments).where(eq(deployments.name, name)).get() || null;
+}
+
+export function getDeployments(username: string) {
+  const db = getDb();
+  return db.select().from(deployments).where(eq(deployments.username, username)).all();
+}
+
+export function deleteDeployment(name: string) {
+  const db = getDb();
+  db.delete(deployments).where(eq(deployments.name, name)).run();
+}
+
+export function getAllDeployments() {
+  const db = getDb();
+  return db.select().from(deployments).all();
+}
+
+// ── Deployment history ───────────────────────────────────────────────────────
+
+interface DeployEvent {
+  action: string;
+  username?: string;
+  type?: string;
+  port?: number;
+  containerId?: string;
+}
+
+export function addDeployEvent(name: string, event: DeployEvent) {
+  const db = getDb();
+  db.insert(history)
+    .values({
+      deploymentName: name,
+      action: event.action,
+      username: event.username || null,
+      type: event.type || null,
+      port: event.port || null,
+      containerId: event.containerId || null,
+      timestamp: new Date().toISOString(),
+    })
+    .run();
+}
+
+export function getDeployHistory(name: string) {
+  const db = getDb();
+  return db.select().from(history).where(eq(history.deploymentName, name)).all();
+}
+
+// ── Request logs ────────────────────────────────────────────────────────────
+
+const MAX_LOGS_PER_APP = 500;
+
+interface RequestEntry {
+  method: string;
+  path: string;
+  status: number;
+  duration: number;
+  timestamp: number;
+}
+
+export function logRequest(name: string, entry: RequestEntry) {
+  const db = getDb();
+  db.insert(requestLogs)
+    .values({
+      deploymentName: name,
+      method: entry.method,
+      path: entry.path,
+      status: entry.status,
+      duration: entry.duration,
+      timestamp: entry.timestamp,
+    })
+    .run();
+
+  // Enforce ring buffer: keep only the most recent MAX_LOGS_PER_APP entries
+  _sqlite!
+    .prepare(
+      `
+    DELETE FROM request_logs
+    WHERE deployment_name = ? AND id NOT IN (
+      SELECT id FROM request_logs
+      WHERE deployment_name = ?
+      ORDER BY id DESC
+      LIMIT ?
+    )
+  `,
+    )
+    .run(name, name, MAX_LOGS_PER_APP);
+}
+
+export function getRequestLogs(name: string) {
+  const db = getDb();
+  return db
+    .select({
+      method: requestLogs.method,
+      path: requestLogs.path,
+      status: requestLogs.status,
+      duration: requestLogs.duration,
+      timestamp: requestLogs.timestamp,
+    })
+    .from(requestLogs)
+    .where(eq(requestLogs.deploymentName, name))
+    .all();
+}
+
+export function getRequestSummary(name: string) {
+  const logs = getRequestLogs(name);
+  if (logs.length === 0)
+    return { total: 0, statusCodes: {} as Record<string, number>, avgDuration: 0, recentRpm: 0 };
+
+  const statusCodes: Record<string, number> = {};
+  let totalDuration = 0;
+  for (const log of logs) {
+    const group = `${Math.floor(log.status / 100)}xx`;
+    statusCodes[group] = (statusCodes[group] || 0) + 1;
+    totalDuration += log.duration;
+  }
+
+  const oneMinAgo = Date.now() - 60_000;
+  const recentCount = logs.filter((l) => l.timestamp > oneMinAgo).length;
+
+  return {
+    total: logs.length,
+    statusCodes,
+    avgDuration: Math.round(totalDuration / logs.length),
+    recentRpm: recentCount,
+  };
+}
+
+// ── Resource metrics ───────────────────────────────────────────────────────
+
+const MAX_METRICS_PER_APP = 2880; // ~24h at 30s intervals
+
+export function logMetrics(name: string, metrics: RawContainerStats) {
+  const db = getDb();
+  db.insert(resourceMetrics)
+    .values({
+      deploymentName: name,
+      cpuPercent: metrics.cpuPercent,
+      memUsageBytes: metrics.memUsageBytes,
+      memLimitBytes: metrics.memLimitBytes,
+      memPercent: metrics.memPercent,
+      netRxBytes: metrics.netRxBytes,
+      netTxBytes: metrics.netTxBytes,
+      blockReadBytes: metrics.blockReadBytes,
+      blockWriteBytes: metrics.blockWriteBytes,
+      pids: metrics.pids,
+      timestamp: metrics.timestamp,
+    })
+    .run();
+
+  _sqlite!
+    .prepare(
+      `
+    DELETE FROM resource_metrics
+    WHERE deployment_name = ? AND id NOT IN (
+      SELECT id FROM resource_metrics
+      WHERE deployment_name = ?
+      ORDER BY id DESC
+      LIMIT ?
+    )
+  `,
+    )
+    .run(name, name, MAX_METRICS_PER_APP);
+}
+
+export function getMetricsHistory(name: string, since: number) {
+  const db = getDb();
+  return db
+    .select({
+      cpuPercent: resourceMetrics.cpuPercent,
+      memUsageBytes: resourceMetrics.memUsageBytes,
+      memLimitBytes: resourceMetrics.memLimitBytes,
+      memPercent: resourceMetrics.memPercent,
+      netRxBytes: resourceMetrics.netRxBytes,
+      netTxBytes: resourceMetrics.netTxBytes,
+      blockReadBytes: resourceMetrics.blockReadBytes,
+      blockWriteBytes: resourceMetrics.blockWriteBytes,
+      pids: resourceMetrics.pids,
+      timestamp: resourceMetrics.timestamp,
+    })
+    .from(resourceMetrics)
+    .where(eq(resourceMetrics.deploymentName, name))
+    .all()
+    .filter((r) => r.timestamp >= since);
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./app/*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", "app/types/**/*.d.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,45 @@
+import tailwindcss from '@tailwindcss/vite';
+import react from '@vitejs/plugin-react';
+import rsc from '@vitejs/plugin-rsc';
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import { reactRouter } from './react-router-vite/plugin.js';
+
+export default defineConfig({
+  clearScreen: false,
+  build: {
+    minify: false,
+  },
+  plugins: [
+    // import("vite-plugin-inspect").then(m => m.default()),
+    tailwindcss(),
+    react(),
+    reactRouter(),
+    rsc({
+      entries: {
+        client: './react-router-vite/entry.browser.tsx',
+        ssr: './react-router-vite/entry.ssr.tsx',
+        rsc: './react-router-vite/entry.rsc.single.tsx',
+      },
+    }),
+  ],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './app'),
+    },
+  },
+  optimizeDeps: {
+    include: ['react-router', 'react-router/internal/react-server-client'],
+    exclude: ['better-sqlite3'],
+  },
+  server: {
+    // Allow connections from iOS simulator and local network devices
+    host: true,
+    // Serve static files from data directory
+    fs: {
+      allow: ['..', './data'],
+    },
+  },
+  // Public directory for static assets
+  publicDir: 'public',
+}) as any;

package/vite.docs.config.ts

@@ -0,0 +1,31 @@
+import tailwindcss from '@tailwindcss/vite';
+import react from '@vitejs/plugin-react';
+import { defineConfig, type Plugin } from 'vite';
+import { resolve } from 'path';
+import { copyFileSync } from 'fs';
+
+function copy404(): Plugin {
+  return {
+    name: 'copy-404',
+    writeBundle(options) {
+      copyFileSync(resolve(__dirname, 'docs-site', '404.html'), resolve(options.dir!, '404.html'));
+    },
+  };
+}
+
+export default defineConfig({
+  root: 'docs-site',
+  base: '/deploy.sh/',
+  build: {
+    outDir: resolve(__dirname, 'dist-docs'),
+    emptyOutDir: true,
+    minify: false,
+  },
+  plugins: [tailwindcss(), react(), copy404()],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './app'),
+    },
+  },
+  publicDir: resolve(__dirname, 'public'),
+});

package/.eslintignore

@@ -1,6 +0,0 @@
-node_modules
-docs
-fixtures
-tmp
-coverage
-website

package/.eslintrc

@@ -1,12 +0,0 @@
-{
-  "extends": ["eslint:recommended", "plugin:jest/recommended"],
-  "plugins": ["jest"],
-  "env": {
-    "es6": true,
-    "node": true
-  },
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module"
-  }
-}

package/.husky/pre-commit

@@ -1,5 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-./node_modules/.bin/eslint .
-./node_modules/.bin/pretty-quick --staged

package/.release-it.json

@@ -1,5 +0,0 @@
-{
-  "github": {
-    "release": true
-  }
-}

package/CHANGELOG.md

@@ -1,56 +0,0 @@
-# 1.0.0 (01/27/2018)
-
-- sub directories would cause deploy to fail, now recursively find the strings and add them manually
-- delete should delete the current working directories deployment if not specified
-- Deployment.del removes the instance metadata from the database using the correct query params
-- refactors CLI to be a class
-- moves from easy-table to turtler
-- fixes login and logout functionality was mixed on cli
-- by default the open command will open the current directory if it is deployed
-- by default the log command will open the current directory if it is deployed
-- logs no longer have a `-` preceding each line
-- logs trim white space instead of adding an empty line
-- delete API actually works now, instead of continuously hanging
-- removes; mkdirp, easy-table, async
-- adds tryitout for docs page generation
-- config is now stored in `${homedir}/.deployrc`
-- getCredentials and cacheCredentials are no longer blocking calls, they will happen async
-- all error responses from the server will contain an error object
-- not-found (application not deployed) and page-could-not-load (proxy errors) pages are now moved into a static directory
-- main landing page is rendered with tryitout
-
-# 0.2.1 (08/15/2017)
-
-- adds the ability to delete deployment and its assets
-- be able to get container status by querying the container on the get call (add to decorator function) is now visible when running (deploy ls) as a status column
-
-# 0.2.0 (08/14/2017)
-
-- deployment model now contains amount of requests
-- stops overloading Deployment.get and breaks out functionality into Deployment.get and Deployment.getAll
-- the request model now captures the http verb associated with the request
-- now captures statusCode for responses in the request model
-- startup and shutdown is now coordinated and less prone to breaking
-
-# 0.1.1 (08/13/2017)
-
-- now is packaged as a universal binary
-- fixes failure when no logs are retrieved from server
-
-# 0.1.0 (08/13/2017)
-
-- adds api and cli action to be able retrieve logs
-- deals with cleaning up old images
-- deletes image and container when application is being redeployed
-- further consolidates deployment logic into the deployment model
-- starts up containers from cold start
-- shuts down containers when process is closing
-- adds caching to static-server
-- abstract models into their own files and their own collections
-- fixes the middleware request logger
-- fixes CLI responses
-- adds whoami functionality that will show the current logged in user (`deploy whoami`)
-
-# 0.0.1 (08/08/2017)
-
-- basic functionality working

package/__tests__/lib/classifier.test.js

@@ -1,49 +0,0 @@
-const path = require("path");
-
-const classifier = require("../../lib/classifier");
-
-describe("@lib/classifier", () => {
-  const baseDirectory = path.resolve(__dirname, "..", "..", "examples");
-
-  test("should be able to classify static site", async () => {
-    const directory = path.resolve(baseDirectory, "static");
-    const output = await classifier(directory);
-
-    expect(output).toEqual({
-      type: "static",
-      build: `\n        FROM mhart/alpine-node:base-8\n        WORKDIR ${directory}\n        ADD . .\n\n        CMD ["node", "index.js"]\n      `,
-    });
-  });
-
-  test("should be able to classify node site", async () => {
-    const directory = path.resolve(baseDirectory, "node");
-    const output = await classifier(directory);
-
-    expect(output).toEqual({
-      type: "node",
-      build: `\n        FROM mhart/alpine-node:8\n        WORKDIR ${directory}\n        ADD . .\n\n        RUN npm install\n\n        CMD ["npm", "start"]\n      `,
-    });
-  });
-
-  test("should be able to classify docker site", async () => {
-    const directory = path.resolve(baseDirectory, "docker");
-    const output = await classifier(directory);
-
-    expect(output).toEqual({
-      type: "docker",
-      build: `FROM mhart/alpine-node:8\nWORKDIR ${directory}\nADD . .\n\nCMD ["node", "index.js"]\n`,
-    });
-  });
-
-  test("should be able to classify unknown deploy target", async () => {
-    const directory = path.resolve(
-      path.resolve(__dirname, "..", "fixtures"),
-      "unknown"
-    );
-    const output = await classifier(directory);
-
-    expect(output).toEqual({
-      type: "unknown",
-    });
-  });
-});

package/__tests__/lib/helpers/util.test.js

@@ -1,57 +0,0 @@
-const os = require("os");
-const fs = require("fs");
-
-const {
-  getPort,
-  hash,
-  contains,
-  mk,
-  rm,
-} = require("../../../lib/helpers/util");
-
-describe("@lib/util", () => {
-  test("@getPort: should be able return a valid port", async () => {
-    let port = await getPort();
-    let port1 = await getPort();
-
-    expect(Number.isInteger(port)).toBeTruthy();
-    expect(Number.isInteger(port1)).toBeTruthy();
-    expect(port !== port1).toBeTruthy();
-  });
-
-  test("@hash: should return a proper lowercase hash", () => {
-    const ret = hash(6);
-    expect(ret.length).toBeTruthy();
-    expect(ret.toLowerCase()).toBeTruthy();
-  });
-
-  test("@contains: should be able to return a proper conditional for truthy and false cases", () => {
-    expect(
-      contains(
-        ["index.html", "main.css"],
-        ["index.html", "!Dockerfile", "!package.json"]
-      )
-    ).toBeTruthy();
-    expect(
-      contains(
-        ["index.html", "main.css", "Dockerfile"],
-        ["index.html", "!Dockerfile", "!package.json"]
-      )
-    ).toBeFalsy();
-    expect(
-      contains([], ["index.html", "!Dockerfile", "!package.json"])
-    ).toBeFalsy();
-  });
-
-  test("@mk / @rm: should be able to make recursive directory", async () => {
-    let directory = `${os.tmpdir()}/hello/world/this/is/a/nested/directory`;
-
-    await mk(directory);
-
-    expect(fs.existsSync(directory)).toBeTruthy();
-
-    await rm(directory);
-
-    expect(!fs.existsSync(directory)).toBeTruthy();
-  });
-});