@aifabrix/server-setup 0.1.0

package/dist/ssh.js

@@ -0,0 +1,122 @@
+/**
+ * SSH client wrapper using ssh2. Used for install, backup, restore.
+ * Never log private keys or sensitive data.
+ */
+import { Client } from 'ssh2';
+import * as fs from 'fs';
+import * as path from 'path';
+export function parseTarget(target) {
+    const at = target.lastIndexOf('@');
+    if (at <= 0 || at === target.length - 1) {
+        throw new Error(`Invalid target "${target}"; use user@host`);
+    }
+    return { user: target.slice(0, at), host: target.slice(at + 1) };
+}
+export function createSSHClient(options) {
+    const { user, host } = parseTarget(options.target);
+    const port = options.port ?? 22;
+    let privateKey;
+    if (options.privateKey) {
+        privateKey = options.privateKey;
+    }
+    else if (options.privateKeyPath) {
+        const resolved = path.resolve(options.privateKeyPath);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Private key file not found: ${resolved}`);
+        }
+        privateKey = fs.readFileSync(resolved, 'utf8');
+    }
+    return new Promise((resolve, reject) => {
+        const conn = new Client();
+        conn
+            .on('ready', () => resolve(conn))
+            .on('error', (err) => reject(err))
+            .connect({
+            host,
+            port,
+            username: user,
+            privateKey: privateKey || undefined,
+            tryKeyboard: !privateKey,
+        });
+    });
+}
+export function exec(conn, command) {
+    return new Promise((resolve, reject) => {
+        conn.exec(command, (err, stream) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            let stdout = '';
+            let stderr = '';
+            stream
+                .on('close', (code) => resolve({ stdout, stderr, code: code ?? null }))
+                .on('data', (data) => { stdout += data.toString(); });
+            stream.stderr.on('data', (data) => { stderr += data.toString(); });
+        });
+    });
+}
+/** Get remote user home directory (e.g. for ~/.ssh). Uses exec so paths work with SFTP. */
+export async function getRemoteHome(conn) {
+    const result = await exec(conn, 'echo $HOME');
+    if (result.code !== 0) {
+        throw new Error('Could not determine remote home directory.');
+    }
+    const home = result.stdout.trim();
+    if (!home) {
+        throw new Error('Remote HOME is empty.');
+    }
+    return home;
+}
+export function readFile(conn, remotePath) {
+    return new Promise((resolve, reject) => {
+        conn.sftp((err, sftp) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            sftp.readFile(remotePath, (err2, data) => {
+                if (err2)
+                    reject(err2);
+                else
+                    resolve(data);
+            });
+        });
+    });
+}
+export function writeFile(conn, remotePath, data) {
+    return new Promise((resolve, reject) => {
+        conn.sftp((err, sftp) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const buf = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+            sftp.writeFile(remotePath, buf, (err2) => {
+                if (err2)
+                    reject(err2);
+                else
+                    resolve();
+            });
+        });
+    });
+}
+export function mkdir(conn, remotePath) {
+    return new Promise((resolve, reject) => {
+        conn.sftp((err, sftp) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            sftp.mkdir(remotePath, (err2) => {
+                if (err2 && err2.code !== 4)
+                    reject(err2); // 4 = already exists
+                else
+                    resolve();
+            });
+        });
+    });
+}
+export function close(conn) {
+    conn.end();
+}

package/dist/ssh.spec.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for SSH helpers (parseTarget). No real SSH connections.
+ */
+export {};

package/dist/ssh.spec.js

@@ -0,0 +1,31 @@
+/**
+ * Unit tests for SSH helpers (parseTarget). No real SSH connections.
+ */
+import { parseTarget } from './ssh.js';
+describe('parseTarget', () => {
+    it('parses user@host', () => {
+        expect(parseTarget('alice@192.168.1.1')).toEqual({
+            user: 'alice',
+            host: '192.168.1.1',
+        });
+    });
+    it('parses user@hostname with multiple @', () => {
+        expect(parseTarget('user@host@extra')).toEqual({
+            user: 'user@host',
+            host: 'extra',
+        });
+    });
+    it('parses single-char user and host', () => {
+        expect(parseTarget('a@b')).toEqual({ user: 'a', host: 'b' });
+    });
+    it('throws when no @', () => {
+        expect(() => parseTarget('nobody')).toThrow('Invalid target');
+        expect(() => parseTarget('nobody')).toThrow('user@host');
+    });
+    it('throws when @ at start', () => {
+        expect(() => parseTarget('@host')).toThrow('Invalid target');
+    });
+    it('throws when @ at end', () => {
+        expect(() => parseTarget('user@')).toThrow('Invalid target');
+    });
+});

package/dist/ubuntu.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Require Ubuntu for local mode (read /etc/os-release). Used before any local execution path.
+ */
+/** Optional path to os-release file for testing (default: /etc/os-release). */
+export declare function requireUbuntu(options?: {
+    osReleasePath?: string;
+}): void;

package/dist/ubuntu.js

@@ -0,0 +1,33 @@
+/**
+ * Require Ubuntu for local mode (read /etc/os-release). Used before any local execution path.
+ */
+import * as fs from 'fs';
+const NOT_UBUNTU_MESSAGE = 'Local mode is supported only on Ubuntu. Use user@host to target an Ubuntu server over SSH.';
+/** Optional path to os-release file for testing (default: /etc/os-release). */
+export function requireUbuntu(options) {
+    if (process.platform !== 'linux') {
+        throw new Error(NOT_UBUNTU_MESSAGE);
+    }
+    const releasePath = options?.osReleasePath ?? '/etc/os-release';
+    let id = '';
+    let idLike = '';
+    try {
+        const content = fs.readFileSync(releasePath, 'utf8');
+        for (const line of content.split('\n')) {
+            const m = line.match(/^ID=(.*)$/);
+            if (m)
+                id = m[1].replace(/^"|"$/g, '').trim();
+            const mLike = line.match(/^ID_LIKE=(.*)$/);
+            if (mLike)
+                idLike = mLike[1].replace(/^"|"$/g, '').trim();
+        }
+    }
+    catch {
+        throw new Error(NOT_UBUNTU_MESSAGE);
+    }
+    const isUbuntu = id === 'ubuntu' || (idLike && idLike.includes('ubuntu'));
+    if (!isUbuntu) {
+        const detected = id || 'unknown';
+        throw new Error(`Local mode is supported only on Ubuntu. Detected: ${detected}. Use user@host to target an Ubuntu server.`);
+    }
+}

package/dist/ubuntu.spec.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for requireUbuntu (local mode OS check) using temp os-release file.
+ */
+export {};

package/dist/ubuntu.spec.js

@@ -0,0 +1,56 @@
+/**
+ * Tests for requireUbuntu (local mode OS check) using temp os-release file.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { requireUbuntu } from './ubuntu.js';
+const TEST_TMP = path.join(process.cwd(), 'tmp', 'ubuntu');
+describe('ubuntu', () => {
+    let releasePath;
+    const originalPlatform = process.platform;
+    beforeAll(() => {
+        fs.mkdirSync(TEST_TMP, { recursive: true });
+        releasePath = path.join(TEST_TMP, `os-release-${Date.now()}`);
+    });
+    afterAll(() => {
+        try {
+            fs.rmSync(TEST_TMP, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+    });
+    it('throws on non-Linux with message to use user@host', () => {
+        Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+        expect(() => requireUbuntu()).toThrow(/Local mode is supported only on Ubuntu/);
+        expect(() => requireUbuntu()).toThrow(/user@host/);
+    });
+    it('throws on Linux when os-release is not Ubuntu', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        fs.writeFileSync(releasePath, 'ID=debian\nID_LIKE=debian\n');
+        expect(() => requireUbuntu({ osReleasePath: releasePath })).toThrow(/Local mode is supported only on Ubuntu/);
+        expect(() => requireUbuntu({ osReleasePath: releasePath })).toThrow(/Detected: debian/);
+    });
+    it('does not throw when ID=ubuntu', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        fs.writeFileSync(releasePath, 'ID=ubuntu\nID_LIKE=debian\n');
+        expect(() => requireUbuntu({ osReleasePath: releasePath })).not.toThrow();
+    });
+    it('does not throw when ID_LIKE contains ubuntu', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        fs.writeFileSync(releasePath, 'ID=pop\nID_LIKE="ubuntu debian"\n');
+        expect(() => requireUbuntu({ osReleasePath: releasePath })).not.toThrow();
+    });
+    it('strips quotes from ID and ID_LIKE', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        fs.writeFileSync(releasePath, 'ID="ubuntu"\nID_LIKE="debian"\n');
+        expect(() => requireUbuntu({ osReleasePath: releasePath })).not.toThrow();
+    });
+    it('throws when os-release file cannot be read', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        expect(() => requireUbuntu({ osReleasePath: path.join(TEST_TMP, 'nonexistent') })).toThrow(/Local mode is supported only on Ubuntu/);
+    });
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@aifabrix/server-setup",
+  "version": "0.1.0",
+  "description": "CLI to install, backup, and restore AI Fabrix builder-server (config + DB) over SSH",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "af-server": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:ci": "npm run lint && npm run test && npm run build",
+    "lint": "eslint src",
+    "test": "jest",
+    "test:cov": "jest --coverage",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "better-sqlite3": "^11.6.0",
+    "commander": "^12.1.0",
+    "extract-zip": "^2.0.1",
+    "ssh2": "^1.15.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/archiver": "^6.0.2",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.2",
+    "@types/ssh2": "^1.15.5",
+    "@typescript-eslint/eslint-plugin": "^8.17.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "eslint": "^9.17.0",
+    "globals": "^15.15.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ]
+}