tdoms-mcp 0.6.1

package/src/connection-store.js

@@ -0,0 +1,126 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { dataDir, normalizeBaseUrl, redactConnection } from "./config.js";
+import { SecretStore } from "./secret-store.js";
+import { atomicWriteFile, withFileLock } from "./storage-utils.js";
+
+const CONNECTIONS_FILE = "connections.json";
+
+export class ConnectionStore {
+  constructor(dir = dataDir(), { env = process.env } = {}) {
+    this.dir = dir;
+    this.filePath = path.join(dir, CONNECTIONS_FILE);
+    this.secrets = new SecretStore(dir, { env });
+  }
+
+  async listConnections() {
+    const state = await this.#readState();
+    return state.connections.map(redactConnection);
+  }
+
+  async getConnection(id, { includeSecrets = false } = {}) {
+    const state = await this.#readState();
+    const connection = state.connections.find((item) => item.id === id);
+    if (!connection) {
+      return undefined;
+    }
+
+    if (!includeSecrets) {
+      return redactConnection(connection);
+    }
+
+    return {
+      ...connection,
+      password: await this.secrets.getSecret(`connection:${id}:password`),
+      token: await this.secrets.getSecret(`connection:${id}:token`)
+    };
+  }
+
+  async upsertConnection(input) {
+    const id = input.id || crypto.randomUUID();
+    let connection;
+    await withFileLock(this.filePath, async () => {
+      const state = await this.#readState();
+      const now = new Date().toISOString();
+      const existing = state.connections.find((item) => item.id === id);
+      connection = {
+        id,
+        name: String(input.name || input.host || "TD/OMS").trim(),
+        protocol: input.protocol || "https",
+        host: String(input.host || "").trim(),
+        port: String(input.port || "45011").trim(),
+        library: String(input.library || "OMS").trim(),
+        username: String(input.username || "").trim(),
+        verifyTls: input.verifyTls !== false,
+        caFile: String(input.caFile || "").trim() || undefined,
+        createdAt: existing?.createdAt || now,
+        updatedAt: now,
+        lastLoginAt: existing?.lastLoginAt,
+        lastSystemProbeAt: existing?.lastSystemProbeAt,
+        lastStatus: existing?.lastStatus || "never-tested"
+      };
+      connection.baseUrl = normalizeBaseUrl(connection);
+
+      const index = state.connections.findIndex((item) => item.id === id);
+      if (index >= 0) state.connections[index] = connection;
+      else state.connections.push(connection);
+      await this.#writeState(state);
+    });
+
+    if (input.password) {
+      await this.secrets.setSecret(`connection:${id}:password`, input.password);
+    }
+
+    return redactConnection(connection);
+  }
+
+  async updateStatus(id, patch) {
+    return withFileLock(this.filePath, async () => {
+      const state = await this.#readState();
+      const index = state.connections.findIndex((item) => item.id === id);
+      if (index < 0) throw new Error(`Connection not found: ${id}`);
+      state.connections[index] = {
+        ...state.connections[index],
+        ...patch,
+        updatedAt: new Date().toISOString()
+      };
+      await this.#writeState(state);
+      return redactConnection(state.connections[index]);
+    });
+  }
+
+  async saveToken(id, token) {
+    await this.secrets.setSecret(`connection:${id}:token`, token);
+    await this.updateStatus(id, {
+      lastStatus: "logged-in",
+      lastLoginAt: new Date().toISOString()
+    });
+  }
+
+  async deleteConnection(id) {
+    await withFileLock(this.filePath, async () => {
+      const state = await this.#readState();
+      state.connections = state.connections.filter((item) => item.id !== id);
+      await this.#writeState(state);
+    });
+    await this.secrets.deleteSecret(`connection:${id}:password`);
+    await this.secrets.deleteSecret(`connection:${id}:token`);
+  }
+
+  async #readState() {
+    try {
+      const parsed = JSON.parse(await fs.readFile(this.filePath, "utf8"));
+      return { connections: Array.isArray(parsed.connections) ? parsed.connections : [] };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { connections: [] };
+      }
+      throw error;
+    }
+  }
+
+  async #writeState(state) {
+    await atomicWriteFile(this.filePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  }
+}

package/src/index.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { DEFAULT_HOST, DEFAULT_PORT, dataDir } from "./config.js";
+import { ConnectionStore } from "./connection-store.js";
+import { ClientManager } from "./client-manager.js";
+import { startMcpServer } from "./mcp-server.js";
+import { startWebServer } from "./web-app.js";
+import { hardenDataDirectory } from "./storage-utils.js";
+
+const command = process.argv[2] || "mcp";
+const profileFlagIndex = process.argv.indexOf("--profile");
+const profile = profileFlagIndex >= 0 ? process.argv[profileFlagIndex + 1] : process.env.TDOMS_MCP_PROFILE;
+
+async function main() {
+  const store = new ConnectionStore();
+  const clientManager = new ClientManager();
+
+  if (command === "ui") {
+    const { host, port } = await startWebServer({ store, clientManager });
+    console.log(`TD/OMS MCP UI: http://${host}:${port}`);
+    console.log(`Data directory: ${dataDir()}`);
+    return;
+  }
+
+  if (command === "dev") {
+    const { host, port } = await startWebServer({ store, clientManager });
+    console.error(`TD/OMS MCP UI: http://${host}:${port}`);
+    await startMcpServer({ store, profile });
+    return;
+  }
+
+  if (command === "smoke") {
+    console.log(JSON.stringify({
+      ok: true,
+      dataDir: dataDir(),
+      connections: await store.listConnections()
+    }, null, 2));
+    return;
+  }
+
+  if (command === "secure-storage") {
+    const security = await hardenDataDirectory(dataDir());
+    console.log(JSON.stringify({ ok: true, dataDir: dataDir(), security }, null, 2));
+    return;
+  }
+
+  if (command === "clients") {
+    console.log(JSON.stringify({ clients: await clientManager.listClients() }, null, 2));
+    return;
+  }
+
+  if (command === "install-client") {
+    const clientId = process.argv[3];
+    if (!clientId) throw new Error("Client id is required. Run `tdoms-mcp clients` to list detected clients.");
+    const result = await clientManager.installClient(clientId, { confirm: process.argv.includes("--confirm") });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (command === "install-detected") {
+    const result = await clientManager.installDetected({ confirm: process.argv.includes("--confirm") });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (command === "mcp") {
+    await startMcpServer({ store, profile });
+    return;
+  }
+
+  console.error(`Unknown command: ${command}`);
+  console.error("Expected one of: mcp, ui, dev, smoke, secure-storage, clients, install-client, install-detected");
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});