@nhic-lab/srv-wrapper 0.1.0

package/dist/daemon/ssh-manager.js

@@ -0,0 +1,231 @@
+import { Client } from 'ssh2';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveJumpPath } from './jump-chain.js';
+export class InMemoryHostKeyStore {
+    fingerprints = new Map();
+    get(serverId) {
+        return this.fingerprints.get(serverId);
+    }
+    set(serverId, fingerprint) {
+        this.fingerprints.set(serverId, fingerprint);
+    }
+}
+/**
+ * Persists TOFU host-key pinning in the Registry's sqlite database so pins
+ * survive daemon restarts (launchd restarts the daemon on login/crash).
+ */
+export class RegistryHostKeyStore {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    get(serverId) {
+        return this.registry.get(serverId)?.hostKeyFingerprint;
+    }
+    set(serverId, fingerprint) {
+        this.registry.setHostKeyFingerprint(serverId, fingerprint);
+    }
+}
+/**
+ * Reads a private key file, restricted to ~/.ssh so a malicious or mistaken
+ * keyPath value (registered via the dashboard) can't be used to read arbitrary
+ * files on the machine. realpathSync resolves the full symlink chain first,
+ * so a symlink inside ~/.ssh pointing outside it is rejected too.
+ */
+function readPrivateKeyFile(keyPath) {
+    const sshDir = fs.realpathSync(path.join(os.homedir(), '.ssh'));
+    let resolved;
+    try {
+        resolved = fs.realpathSync(keyPath);
+    }
+    catch {
+        throw new Error(`key file not found: ${keyPath}`);
+    }
+    if (resolved !== sshDir && !resolved.startsWith(sshDir + path.sep)) {
+        throw new Error(`key path must be inside ~/.ssh (got: ${keyPath})`);
+    }
+    return fs.readFileSync(resolved, 'utf-8');
+}
+function defaultConnect(server, secret, hostKeyStore, viaStream, readyTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const client = new Client();
+        client.on('ready', () => resolve(client));
+        client.on('error', reject);
+        let authOpts;
+        if (server.authMethod === 'password') {
+            authOpts = { password: secret };
+        }
+        else {
+            if (!server.keyPath)
+                throw new Error('keyPath is required for key-based authentication');
+            authOpts = { privateKey: readPrivateKeyFile(server.keyPath), passphrase: secret };
+        }
+        const connectOpts = viaStream
+            ? { sock: viaStream, username: server.username, ...authOpts }
+            : { host: server.host, port: server.port, username: server.username, ...authOpts };
+        if (readyTimeoutMs !== undefined)
+            connectOpts.readyTimeout = readyTimeoutMs;
+        if (hostKeyStore) {
+            connectOpts.hostHash = 'sha256';
+            connectOpts.hostVerifier = (fingerprint) => {
+                const expected = hostKeyStore.get(server.id);
+                if (!expected) {
+                    hostKeyStore.set(server.id, fingerprint);
+                    return true;
+                }
+                return expected === fingerprint;
+            };
+        }
+        client.connect(connectOpts);
+    });
+}
+function closeChainClients(clients) {
+    // Unwind in reverse: target first, back to the first hop.
+    for (let i = clients.length - 1; i >= 0; i--) {
+        try {
+            clients[i].end();
+        }
+        catch {
+            // already closed; nothing to do
+        }
+    }
+}
+export class SshManager {
+    secretResolver;
+    connectFn;
+    hostKeyStore;
+    serverLookup;
+    static TEST_CONNECT_TIMEOUT_MS = 8000;
+    sessions = new Map();
+    constructor(secretResolver, connectFn = defaultConnect, hostKeyStore = new InMemoryHostKeyStore(), serverLookup = () => undefined) {
+        this.secretResolver = secretResolver;
+        this.connectFn = connectFn;
+        this.hostKeyStore = hostKeyStore;
+        this.serverLookup = serverLookup;
+    }
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    /**
+     * Connects to `server`, tunneling through its fully-expanded jumpChain (if
+     * any) one hop at a time via `client.forwardOut`. Returns every connected
+     * Client in hop order, last entry being the connection to `server` itself.
+     * When there's no jumpChain this degenerates to a single direct connect.
+     *
+     * `targetSecretOverride`, when given, supplies the secret for `server`
+     * itself instead of `secretResolver` — used by testConnect() to test a
+     * not-yet-saved server (whose secret isn't in the Keychain yet). Every
+     * other hop in the chain is still an existing registered server, so its
+     * secret still comes from the resolver as usual.
+     */
+    async connectChain(server, targetSecretOverride, readyTimeoutMs) {
+        const hopIds = server.jumpChain && server.jumpChain.length > 0
+            ? resolveJumpPath(server.id, server.jumpChain, this.serverLookup)
+            : [server.id];
+        const clients = [];
+        try {
+            for (let i = 0; i < hopIds.length; i++) {
+                const id = hopIds[i];
+                const record = id === server.id ? server : this.serverLookup(id);
+                if (!record)
+                    throw new Error(`jump chain references unknown server id "${id}"`);
+                const secret = id === server.id && targetSecretOverride !== undefined ? targetSecretOverride : this.secretResolver(id);
+                if (i === 0) {
+                    clients.push(await this.connectFn(record, secret, this.hostKeyStore, undefined, readyTimeoutMs));
+                }
+                else {
+                    const previousClient = clients[clients.length - 1];
+                    const stream = await new Promise((resolve, reject) => {
+                        previousClient.forwardOut('127.0.0.1', 0, record.host, record.port, (err, stream) => {
+                            if (err)
+                                return reject(err);
+                            resolve(stream);
+                        });
+                    });
+                    clients.push(await this.connectFn(record, secret, this.hostKeyStore, stream, readyTimeoutMs));
+                }
+            }
+        }
+        catch (err) {
+            // A later hop failed (bad auth, unreachable, etc.) — close whatever
+            // earlier hops already connected instead of leaking them.
+            closeChainClients(clients);
+            throw err;
+        }
+        return clients;
+    }
+    /**
+     * Opens a connection to `server` (through its jumpChain, if any) and
+     * immediately closes it — used to check reachability/credentials without
+     * running a command. `secretOverride` lets callers test a server that
+     * isn't registered yet (e.g. the dashboard's "test connection" button on
+     * an unsaved form), whose secret isn't in the Keychain.
+     */
+    async testConnect(server, secretOverride) {
+        const clients = await this.connectChain(server, secretOverride, SshManager.TEST_CONNECT_TIMEOUT_MS);
+        closeChainClients(clients);
+    }
+    async exec(server, command, onData) {
+        const clients = await this.connectChain(server);
+        const client = clients[clients.length - 1];
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            client.exec(command, (err, channel) => {
+                if (err) {
+                    settled = true;
+                    closeChainClients(clients);
+                    return reject(err);
+                }
+                channel.on('data', (data) => onData('stdout', data.toString()));
+                channel.stderr.on('data', (data) => onData('stderr', data.toString()));
+                channel.on('close', (code) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    closeChainClients(clients);
+                    resolve(code);
+                });
+                channel.on('error', (chanErr) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    closeChainClients(clients);
+                    reject(chanErr);
+                });
+            });
+        });
+    }
+    async startSession(server, onData) {
+        const clients = await this.connectChain(server);
+        const client = clients[clients.length - 1];
+        const channel = await new Promise((resolve, reject) => {
+            client.shell((err, ch) => (err ? reject(err) : resolve(ch)));
+        });
+        channel.on('data', (data) => onData(data.toString()));
+        const sessionId = randomUUID();
+        channel.on('error', (err) => {
+            console.error(`srvd: session channel error for ${sessionId}:`, err);
+            this.sessions.delete(sessionId);
+            closeChainClients(clients);
+        });
+        this.sessions.set(sessionId, { clients, channel });
+        return sessionId;
+    }
+    sendToSession(sessionId, command) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`No open session ${sessionId}`);
+        session.channel.write(command);
+    }
+    stopSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.channel.end();
+        closeChainClients(session.clients);
+        this.sessions.delete(sessionId);
+    }
+}

package/dist/shared/paths.js

@@ -0,0 +1,17 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+export function srvHome() {
+    return path.join(homedir(), '.srv');
+}
+export function srvSocketPath() {
+    return path.join(srvHome(), 'srv.sock');
+}
+export function srvRegistryDbPath() {
+    return path.join(srvHome(), 'registry.db');
+}
+export function srvLogDbPath() {
+    return path.join(srvHome(), 'log.db');
+}
+export function srvKeysDir() {
+    return path.join(srvHome(), 'keys');
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nhic-lab/srv-wrapper",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Local daemon + CLI that lets AI agents run commands on registered servers by an opaque server-id only, never seeing real hostnames or credentials.",
+  "keywords": [
+    "ssh",
+    "cli",
+    "daemon",
+    "ai-agent",
+    "server-management",
+    "audit-log"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nhic-lab/srv-wrapper.git"
+  },
+  "homepage": "https://github.com/nhic-lab/srv-wrapper#readme",
+  "bugs": {
+    "url": "https://github.com/nhic-lab/srv-wrapper/issues"
+  },
+  "os": [
+    "darwin"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "bin": {
+    "srv": "dist/cli/index.js",
+    "srvd": "dist/daemon/index.js"
+  },
+  "files": [
+    "dist",
+    "public",
+    "scripts/install-launchd.sh",
+    "scripts/com.srv-wrapper.daemon.plist",
+    "scripts/compact-log.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "dev:daemon": "tsx src/daemon/index.ts",
+    "compact-log": "node scripts/compact-log.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "better-sqlite3": "^13.0.2",
+    "commander": "^15.0.0",
+    "express": "^5.2.1",
+    "ssh2": "^1.17.0",
+    "ws": "^8.21.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.1.2",
+    "@types/ssh2": "^1.15.5",
+    "@types/supertest": "^7.2.1",
+    "@types/ws": "^8.18.1",
+    "supertest": "^7.2.2",
+    "tsx": "^4.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  }
+}