@meshxdata/fops 0.1.34 → 0.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshxdata/fops",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "CLI to install and manage data mesh platforms",
   "keywords": [
     "fops",

package/src/agent/llm.js

@@ -559,11 +559,11 @@ function resolveProvider(opts, { anthropicKey, openaiKey, azureConfig, useClaude
  */
 function defaultModelForProvider(provider, opts, { anthropicKey, azureConfig }) {
   if (opts.model) return opts.model;
-  if (provider === "anthropic" || provider === "claude_code") return process.env.ANTHROPIC_MODEL?.trim() || "claude-opus-4-20250514";
+  if (provider === "anthropic" || provider === "claude_code") return process.env.ANTHROPIC_MODEL?.trim() || "claude-sonnet-4-6";
   if (provider === "azure") return azureConfig?.deployment || "gpt-4o";
   if (provider === "openai") return process.env.OPENAI_MODEL?.trim() || "gpt-5";
   // Fallback
-  return anthropicKey ? (process.env.ANTHROPIC_MODEL?.trim() || "claude-opus-4-20250514") : azureConfig ? azureConfig.deployment : "gpt-5";
+  return anthropicKey ? (process.env.ANTHROPIC_MODEL?.trim() || "claude-sonnet-4-6") : azureConfig ? azureConfig.deployment : "gpt-5";
 }
 
 export async function streamAssistantReply(root, messages, systemContent, opts) {
@@ -794,7 +794,7 @@ export async function callClaudeWithTools(messages, systemContent, tools, opts =
   const cached = getAnthropicModule();
   const { default: Anthropic } = cached || await import("@anthropic-ai/sdk");
   const client = new Anthropic({ apiKey: anthropicKey });
-  const model = opts.model || process.env.ANTHROPIC_MODEL?.trim() || "claude-opus-4-20250514";
+  const model = opts.model || process.env.ANTHROPIC_MODEL?.trim() || "claude-sonnet-4-6";
   const claudeTools = toClaudeTools(tools);
 
   // Redact PII from context before sending

package/src/plugins/bundled/fops-plugin-dai-ttyd/fops.plugin.json

@@ -0,0 +1,6 @@
+{
+  "id": "fops-plugin-dai-ttyd",
+  "name": "DAI Talk-to-your-Data",
+  "version": "0.1.0",
+  "description": "Natural language queries against the DAI TTYD (Talk-to-your-Data) service"
+}

package/src/plugins/bundled/fops-plugin-dai-ttyd/index.js

@@ -0,0 +1,182 @@
+import chalk from "chalk";
+import { DaiTTYDClient } from "./lib/client.js";
+
+const DIM = chalk.dim;
+const OK = chalk.green;
+const ERR = chalk.red;
+const ACCENT = chalk.cyan;
+const BOLD = chalk.bold;
+const WARN = chalk.yellow;
+
+export function register(api) {
+  const client = new DaiTTYDClient(api.config);
+
+  function clientFor({ url, jwt } = {}) {
+    if (!url && !jwt) return client;
+    return new DaiTTYDClient({
+      ...api.config,
+      ...(url && { baseUrl: url }),
+      ...(jwt && { authToken: jwt }),
+    });
+  }
+
+  // ─── Doctor check ────────────────────────────────────────────────────────
+  api.registerDoctorCheck({
+    name: "dai-ttyd: auth token",
+    fn: async () => {
+      const token =
+        api.config?.authToken?.trim() || process.env.DAI_AUTH_TOKEN?.trim();
+      if (!token) {
+        return {
+          ok: false,
+          message: "DAI_AUTH_TOKEN not set — configure via env or ~/.fops.json plugins.entries.fops-plugin-dai-ttyd.config.authToken",
+        };
+      }
+      return { ok: true, message: "DAI_AUTH_TOKEN is set" };
+    },
+  });
+
+  // ─── Agent tools ─────────────────────────────────────────────────────────
+
+  api.registerTool({
+    name: "ttyd_thread_create",
+    description: "Create a new TTYD conversation thread. Returns a thread_id to use with ttyd_ask.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Optional title for the thread" },
+      },
+    },
+    async execute({ title } = {}) {
+      const threadId = await client.createThread(title || "fops session");
+      return JSON.stringify({ thread_id: threadId });
+    },
+  });
+
+  api.registerTool({
+    name: "ttyd_ask",
+    description:
+      "Ask a natural-language question to the DAI Talk-to-your-Data service. " +
+      "Returns the generated SQL and a text summary/answer. " +
+      "Optionally scoped to a dashboard or tile for context. " +
+      "If thread_id is omitted, a new thread is created automatically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The natural-language question to ask" },
+        thread_id: { type: "number", description: "Existing thread id for multi-turn conversations" },
+        dashboard_id: { type: "number", description: "Optional dashboard id for context" },
+        tile_id: { type: "number", description: "Optional tile id for context" },
+      },
+      required: ["question"],
+    },
+    async execute({ question, thread_id, dashboard_id, tile_id }) {
+      const result = await client.ask(question, {
+        threadId: thread_id,
+        dashboardId: dashboard_id,
+        tileId: tile_id,
+      });
+      return JSON.stringify(result);
+    },
+  });
+
+  // ─── CLI commands ─────────────────────────────────────────────────────────
+
+  api.registerCommand((program) => {
+    const ttyd = program
+      .command("ttyd")
+      .description("Talk-to-your-Data — query data with natural language")
+      .option("--url <url>", "Override the TTYD base URL (e.g. https://api-live.dashboards.ai)")
+      .option("--jwt <token>", "Bearer token (overrides DAI_AUTH_TOKEN env)");
+
+    // fops ttyd ask "<question>"
+    ttyd
+      .command("ask <question>")
+      .description("Ask a natural-language question and stream the answer")
+      .option("--thread <id>", "Reuse an existing thread id (for follow-up questions)", (v) => Number(v))
+      .option("--dashboard <id>", "Scope to a dashboard id", (v) => Number(v))
+      .option("--tile <id>", "Scope to a tile id", (v) => Number(v))
+      .option("--json", "Output raw JSON instead of formatted text")
+      .option("--debug", "Print raw SSE events")
+      .action(async (question, opts) => {
+        const { url, jwt } = ttyd.opts();
+        const c = clientFor({ url, jwt });
+
+        let threadId = opts.thread ?? null;
+        if (threadId == null) {
+          process.stdout.write(DIM("  Creating thread... "));
+          try {
+            threadId = await c.createThread();
+            process.stdout.write(DIM(`thread ${threadId}\n`));
+          } catch (e) {
+            process.stdout.write(WARN(`skipped (${e.message})\n`));
+            // Proceed without a thread_id — server may create one implicitly
+          }
+        }
+
+        console.log(ACCENT(`\n  ── Asking ${"─".repeat(44)}`));
+        console.log(DIM(`  ${question}\n`));
+
+        let sql = "";
+        const summaryParts = [];
+
+        try {
+          for await (const event of c.askStream(question, threadId, {
+            dashboardId: opts.dashboard,
+            tileId: opts.tile,
+          })) {
+            if (opts.debug) console.error(DIM(`[sse] ${JSON.stringify(event)}`));
+            if (event.type === "sql") {
+              sql = event.content ?? "";
+              if (!opts.json) {
+                console.log(BOLD("  SQL:"));
+                for (const line of sql.split("\n")) {
+                  console.log(DIM(`    ${line}`));
+                }
+                console.log();
+              }
+            } else if (event.type === "answer") {
+              const chunk = event.content ?? "";
+              summaryParts.push(chunk);
+              if (!opts.json) process.stdout.write(chunk);
+            } else if (event.type === "error") {
+              throw new Error(event.message ?? "TTYD error");
+            } else if (event.type === "done") {
+              break;
+            }
+          }
+        } catch (e) {
+          console.error(ERR(`\n  ✗ ${e.message}`));
+          return;
+        }
+
+        if (!opts.json) {
+          if (summaryParts.length > 0) process.stdout.write("\n");
+          if (threadId != null) {
+            console.log(DIM(`\n  thread: ${threadId}`));
+            console.log(DIM("  Use --thread to continue this conversation.\n"));
+          } else {
+            console.log();
+          }
+        } else {
+          console.log(JSON.stringify({ thread_id: threadId, sql, summary: summaryParts.join("") }, null, 2));
+        }
+      });
+
+    // fops ttyd thread new [title]
+    const thread = ttyd
+      .command("thread")
+      .description("Manage TTYD threads");
+
+    thread
+      .command("new [title]")
+      .description("Create a new conversation thread")
+      .action(async (title = "fops session") => {
+        const { url, jwt } = ttyd.opts();
+        const c = clientFor({ url, jwt });
+        const threadId = await c.createThread(title);
+        console.log(OK(`  ✓ Thread created: ${threadId}`));
+        console.log(DIM(`  Use: fops ttyd ask --thread ${threadId} "<question>"\n`));
+      });
+  });
+}

package/src/plugins/bundled/fops-plugin-dai-ttyd/lib/client.js

@@ -0,0 +1,164 @@
+import http from "node:http";
+import https from "node:https";
+
+const DEFAULT_BASE_URL = "https://api.dashboards.ai";
+
+function resolveBaseUrl(config) {
+  return (
+    config?.baseUrl?.trim() ||
+    process.env.DAI_TTYD_URL?.trim() ||
+    DEFAULT_BASE_URL
+  ).replace(/\/+$/, "");
+}
+
+function resolveAuthToken(config) {
+  const raw = config?.authToken || process.env.DAI_AUTH_TOKEN || "";
+  return raw.replace(/\s+/g, ""); // strip whitespace/newlines from env or shell wrapping
+}
+
+export class DaiTTYDClient {
+  constructor(config = {}) {
+    this.baseUrl = resolveBaseUrl(config);
+    this.authToken = resolveAuthToken(config);
+  }
+
+  _headers() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${this.authToken}`,
+    };
+  }
+
+  /** POST /ttyd/threads → thread id (number) */
+  async createThread(title = "fops session") {
+    const url = `${this.baseUrl}/ttyd/threads`;
+    let { status, data } = await request("POST", url, this._headers(), { title });
+    // Backend may return 400 "User with email already exists" on the first call
+    // when auto-provisioning the user — retry once, it should succeed
+    if (status === 400 && data.includes("already exists")) {
+      ({ status, data } = await request("POST", url, this._headers(), { title }));
+    }
+    if (status >= 400) throw new Error(`Failed to create thread (HTTP ${status}): ${data}`);
+    const body = JSON.parse(data);
+    const id = body.id ?? body.thread_id;
+    if (id == null) throw new Error(`No thread id in response: ${data}`);
+    return id;
+  }
+
+  /**
+   * POST /ttyd/answer/stream — async generator yielding SSE event objects.
+   * Each event: { type: "sql"|"answer"|"done"|"error", content?: string, message?: string }
+   */
+  async *askStream(question, threadId, { dashboardId, tileId } = {}) {
+    const url = `${this.baseUrl}/ttyd/answer/stream`;
+    const payload = { question, thread_id: threadId };
+    if (dashboardId != null) payload.dashboard_id = Number(dashboardId);
+    if (tileId != null) payload.tile_id = Number(tileId);
+    yield* streamSSE("POST", url, this._headers(), payload);
+  }
+
+  /** Convenience: create a thread, ask one question, collect full sql + summary. */
+  async ask(question, { threadId, dashboardId, tileId } = {}) {
+    const id = threadId ?? (await this.createThread());
+    let sql = "";
+    const summaryParts = [];
+    for await (const event of this.askStream(question, id, { dashboardId, tileId })) {
+      if (event.type === "sql") sql = event.content ?? "";
+      else if (event.type === "answer") summaryParts.push(event.content ?? "");
+      else if (event.type === "error") throw new Error(event.message ?? "TTYD error");
+      else if (event.type === "done") break;
+    }
+    return { threadId: id, sql, summary: summaryParts.join("") };
+  }
+
+  /** Verify connectivity — returns true/false. */
+  async ping() {
+    try {
+      const url = `${this.baseUrl}/ttyd/threads`;
+      const { status } = await request("POST", url, this._headers(), { title: "ping" });
+      return status < 500;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function request(method, url, headers, body, timeoutMs = 15_000) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const lib = parsed.protocol === "https:" ? https : http;
+    const encoded = JSON.stringify(body);
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      headers: { ...headers, "Content-Length": Buffer.byteLength(encoded) },
+      timeout: timeoutMs,
+    };
+    const req = lib.request(options, (res) => {
+      let data = "";
+      res.on("data", (c) => { data += c; });
+      res.on("end", () => resolve({ status: res.statusCode, data }));
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("Request timeout")); });
+    req.write(encoded);
+    req.end();
+  });
+}
+
+/**
+ * Async generator that streams SSE from an HTTP endpoint.
+ * Yields parsed JSON objects from each "data: {...}" line.
+ */
+async function* streamSSE(method, url, headers, body, timeoutMs = 300_000) {
+  const parsed = new URL(url);
+  const lib = parsed.protocol === "https:" ? https : http;
+  const encoded = JSON.stringify(body);
+  const options = {
+    hostname: parsed.hostname,
+    port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+    path: parsed.pathname + parsed.search,
+    method,
+    headers: {
+      ...headers,
+      "Content-Length": Buffer.byteLength(encoded),
+      Accept: "text/event-stream",
+    },
+    timeout: timeoutMs,
+  };
+
+  const res = await new Promise((resolve, reject) => {
+    const req = lib.request(options, resolve);
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("Stream timeout")); });
+    req.write(encoded);
+    req.end();
+  });
+
+  if (res.statusCode >= 400) {
+    let errData = "";
+    for await (const chunk of res) errData += chunk;
+    throw new Error(`HTTP ${res.statusCode}: ${errData}`);
+  }
+
+  let buffer = "";
+  for await (const chunk of res) {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop(); // keep any incomplete line
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue;
+      const raw = line.slice("data:".length).trim();
+      if (!raw) continue;
+      let data;
+      try { data = JSON.parse(raw); } catch { continue; }
+      yield data;
+      if (data?.type === "done" || data?.type === "error") return;
+    }
+  }
+}

package/src/plugins/bundled/fops-plugin-dai-ttyd/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/src/plugins/bundled/fops-plugin-foundation/index.js

@@ -1527,8 +1527,19 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     }
 
     @objc func runUpdate() {
+        updateItem.title = "⬆ Updating…"
+        updateItem.isEnabled = false
         let npm = "/opt/homebrew/bin/npm"
-        openTerminal(command: npm + " install -g @meshxdata/fops")
+        let p = Process()
+        p.executableURL = URL(fileURLWithPath: npm)
+        p.arguments = ["install", "-g", "@meshxdata/fops"]
+        p.terminationHandler = { _ in
+            DispatchQueue.main.async {
+                updateItem.title = "✓ Updated — restart tray to apply"
+                updateItem.isEnabled = false
+            }
+        }
+        try? p.run()
     }
 
     // Rebuild Compose submenu each time it opens

package/src/ui/tui/App.js

@@ -2790,7 +2790,7 @@ function TuiApp({ core, version, root }) {
     h(Box, { flexShrink: 0 },
       h(StatusBar, {
         agentName: activeSession?.agent,
-        model: core.opts.model || (providerLabel === "azure-openai" ? "azure-openai" : providerLabel === "openai" ? "openai" : "claude-sonnet"),
+        model: core.opts.model || (providerLabel === "azure-openai" ? "azure-openai" : providerLabel === "openai" ? "openai" : process.env.ANTHROPIC_MODEL?.trim() || "claude-sonnet-4-6"),
         tokenCount: tokenCount || (activeSession ? (core.sessions.get(activeId)?.tokenCount || 0) : 0),
         cacheReadTokens,
         version,