@naia-team/cli 0.1.0

package/src/commands/mcp-serve.js

@@ -0,0 +1,224 @@
+import { stdin, stdout } from "node:process";
+import { loadPlatformRuntimeContext, platformApiCall } from "../lib/platform-client.js";
+
+const TOOLS = [
+  {
+    name: "naia_invoices_list",
+    description: "List invoices from Naia platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        direction: { type: "string", enum: ["issued", "received", "third_party"] },
+        documentStatus: { type: "string", enum: ["draft", "issued", "voided", "rectified"] },
+        paymentStatus: { type: "string", enum: ["unpaid", "partial", "paid"] },
+        entityId: { type: "string" },
+        limit: { type: "number" },
+      },
+    },
+  },
+  {
+    name: "naia_entities_search",
+    description: "Search entities by name/taxId.",
+    inputSchema: { type: "object", properties: { query: { type: "string" }, taxId: { type: "string" }, limit: { type: "number" } } },
+  },
+  {
+    name: "naia_contacts_list",
+    description: "List contacts by entity or name.",
+    inputSchema: { type: "object", properties: { entityId: { type: "string" }, name: { type: "string" } } },
+  },
+  {
+    name: "naia_invoices_create_draft",
+    description: "Create invoice draft in Naia.",
+    inputSchema: {
+      type: "object",
+      required: ["issueDate", "description", "amount"],
+      properties: {
+        issueDate: { type: "string" },
+        description: { type: "string" },
+        amount: { type: "number" },
+        entityId: { type: "string" },
+        entityName: { type: "string" },
+        entityTaxId: { type: "string" },
+        quantity: { type: "number" },
+        taxPercent: { type: "number" },
+        dueDate: { type: "string" },
+        invoiceNumber: { type: "string" },
+        notes: { type: "string" },
+      },
+    },
+  },
+  {
+    name: "naia_invoices_issue",
+    description: "Issue invoice by id.",
+    inputSchema: {
+      type: "object",
+      required: ["invoiceId"],
+      properties: { invoiceId: { type: "string" }, seriesId: { type: "string" } },
+    },
+  },
+];
+
+let runtimeContextPromise = null;
+let buffer = Buffer.alloc(0);
+
+export async function runMcpServe() {
+  stdin.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    void drainBuffer();
+  });
+}
+
+async function drainBuffer() {
+  while (true) {
+    const delimiterIndex = buffer.indexOf("\r\n\r\n");
+    if (delimiterIndex < 0) return;
+    const headerText = buffer.subarray(0, delimiterIndex).toString("utf8");
+    const contentLength = parseContentLength(headerText);
+    if (contentLength < 0) {
+      buffer = Buffer.alloc(0);
+      return;
+    }
+    const totalLength = delimiterIndex + 4 + contentLength;
+    if (buffer.length < totalLength) return;
+    const bodyBuffer = buffer.subarray(delimiterIndex + 4, totalLength);
+    buffer = buffer.subarray(totalLength);
+    await handleMessage(bodyBuffer.toString("utf8"));
+  }
+}
+
+function parseContentLength(headerText) {
+  const lines = headerText.split("\r\n");
+  for (const line of lines) {
+    const [name, value] = line.split(":").map((part) => part.trim());
+    if (name.toLowerCase() === "content-length") {
+      const parsed = Number.parseInt(value ?? "", 10);
+      return Number.isFinite(parsed) ? parsed : -1;
+    }
+  }
+  return -1;
+}
+
+async function handleMessage(raw) {
+  let request;
+  try {
+    request = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!request.id && request.method === "notifications/initialized") return;
+
+  try {
+    const result = await dispatch(request);
+    if (request.id !== undefined) {
+      writeResponse({ jsonrpc: "2.0", id: request.id ?? null, result });
+    }
+  } catch (error) {
+    if (request.id !== undefined) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id: request.id ?? null,
+        error: { code: -32000, message: error instanceof Error ? error.message : String(error) },
+      });
+    }
+  }
+}
+
+async function dispatch(request) {
+  if (request.method === "initialize") {
+    return {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "naia-mcp", version: "0.1.0" },
+    };
+  }
+  if (request.method === "tools/list") {
+    return { tools: TOOLS };
+  }
+  if (request.method === "tools/call") {
+    const params = request.params ?? {};
+    const name = asString(params.name);
+    const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+    const data = await callTool(name, args);
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+  if (request.method === "ping") {
+    return { ok: true };
+  }
+  throw new Error(`Unsupported method: ${request.method}`);
+}
+
+async function callTool(name, args) {
+  const context = await getRuntimeContext();
+  if (name === "naia_invoices_list") {
+    const query = new URLSearchParams();
+    if (asString(args.direction)) query.set("direction", asString(args.direction));
+    if (asString(args.documentStatus)) query.set("documentStatus", asString(args.documentStatus));
+    if (asString(args.paymentStatus)) query.set("paymentStatus", asString(args.paymentStatus));
+    if (asString(args.entityId)) query.set("entityId", asString(args.entityId));
+    if (asNumber(args.limit)) query.set("limit", String(asNumber(args.limit)));
+    return platformApiCall(context, `/api/agents/v1/platform/invoices/list?${query.toString()}`, { method: "GET" });
+  }
+  if (name === "naia_entities_search") {
+    const query = new URLSearchParams();
+    if (asString(args.query)) query.set("query", asString(args.query));
+    if (asString(args.taxId)) query.set("taxId", asString(args.taxId));
+    if (asNumber(args.limit)) query.set("limit", String(asNumber(args.limit)));
+    return platformApiCall(context, `/api/agents/v1/platform/entities/search?${query.toString()}`, { method: "GET" });
+  }
+  if (name === "naia_contacts_list") {
+    const query = new URLSearchParams();
+    if (asString(args.entityId)) query.set("entityId", asString(args.entityId));
+    if (asString(args.name)) query.set("name", asString(args.name));
+    return platformApiCall(context, `/api/agents/v1/platform/contacts/list?${query.toString()}`, { method: "GET" });
+  }
+  if (name === "naia_invoices_create_draft") {
+    const payload = {
+      issueDate: asString(args.issueDate),
+      description: asString(args.description),
+      amount: asNumber(args.amount),
+    };
+    if (!payload.issueDate || !payload.description || typeof payload.amount !== "number") {
+      throw new Error("naia_invoices_create_draft requires issueDate, description, amount");
+    }
+    for (const key of ["entityId", "entityName", "entityTaxId", "dueDate", "invoiceNumber", "notes"]) {
+      const value = asString(args[key]);
+      if (value) payload[key] = value;
+    }
+    for (const key of ["quantity", "taxPercent"]) {
+      const value = asNumber(args[key]);
+      if (typeof value === "number") payload[key] = value;
+    }
+    return platformApiCall(context, "/api/agents/v1/platform/invoices/create-draft", { method: "POST", body: payload });
+  }
+  if (name === "naia_invoices_issue") {
+    const invoiceId = asString(args.invoiceId);
+    if (!invoiceId) throw new Error("naia_invoices_issue requires invoiceId");
+    const payload = { invoiceId };
+    const seriesId = asString(args.seriesId);
+    if (seriesId) payload.seriesId = seriesId;
+    return platformApiCall(context, "/api/agents/v1/platform/invoices/issue", { method: "POST", body: payload });
+  }
+  throw new Error(`Unknown tool: ${name}`);
+}
+
+function getRuntimeContext() {
+  if (!runtimeContextPromise) {
+    runtimeContextPromise = loadPlatformRuntimeContext({});
+  }
+  return runtimeContextPromise;
+}
+
+function writeResponse(response) {
+  const body = Buffer.from(JSON.stringify(response), "utf8");
+  const headers = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "utf8");
+  stdout.write(Buffer.concat([headers, body]));
+}
+
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+

package/src/commands/platform.js

@@ -0,0 +1,116 @@
+import { parseArgVector } from "../lib/args.js";
+import { loadPlatformRuntimeContext, platformApiCall } from "../lib/platform-client.js";
+import { printJson } from "../lib/output.js";
+
+export async function runPlatform(args) {
+  const { options, positionals } = parseArgVector(args);
+  const [domain, action, ...rest] = positionals;
+  const context = await loadPlatformRuntimeContext({
+    profile: options.profile,
+    runtimeUrl: options.runtimeUrl,
+    executorId: options.executorId,
+    executorName: options.executorName,
+    executorType: options.executorType,
+  });
+
+  if (domain === "invoices" && action === "list") {
+    await listInvoices(context, rest);
+    return;
+  }
+  if (domain === "invoices" && action === "create-draft") {
+    await createInvoiceDraft(context, rest);
+    return;
+  }
+  if (domain === "invoices" && action === "issue") {
+    await issueInvoice(context, rest);
+    return;
+  }
+  if (domain === "entities" && action === "search") {
+    await searchEntities(context, rest);
+    return;
+  }
+  if (domain === "contacts" && action === "list") {
+    await listContacts(context, rest);
+    return;
+  }
+  throw new Error(`Unsupported platform command: ${[domain, action].filter(Boolean).join(" ")}`);
+}
+
+async function listInvoices(context, args) {
+  const options = parseArgVector(args).options;
+  const query = new URLSearchParams();
+  if (options.direction) query.set("direction", options.direction);
+  if (options.documentStatus) query.set("documentStatus", options.documentStatus);
+  if (options.paymentStatus) query.set("paymentStatus", options.paymentStatus);
+  if (options.entityId) query.set("entityId", options.entityId);
+  if (options.limit) query.set("limit", options.limit);
+  const result = await platformApiCall(context, `/api/agents/v1/platform/invoices/list?${query.toString()}`, {
+    method: "GET",
+  });
+  printJson(result);
+}
+
+async function createInvoiceDraft(context, args) {
+  const options = parseArgVector(args).options;
+  const issueDate = options.issueDate;
+  const description = options.description;
+  const amount = options.amount ? Number.parseFloat(options.amount) : NaN;
+  if (!issueDate || !description || !Number.isFinite(amount)) {
+    throw new Error("create-draft requires --issue-date YYYY-MM-DD --description --amount");
+  }
+
+  const payload = { issueDate, description, amount };
+  if (options.entityId) payload.entityId = options.entityId;
+  if (options.entityName) payload.entityName = options.entityName;
+  if (options.entityTaxId) payload.entityTaxId = options.entityTaxId;
+  if (options.quantity) payload.quantity = Number.parseFloat(options.quantity);
+  if (options.taxPercent) payload.taxPercent = Number.parseFloat(options.taxPercent);
+  if (options.dueDate) payload.dueDate = options.dueDate;
+  if (options.invoiceNumber) payload.invoiceNumber = options.invoiceNumber;
+  if (options.notes) payload.notes = options.notes;
+
+  const result = await platformApiCall(context, "/api/agents/v1/platform/invoices/create-draft", {
+    method: "POST",
+    body: payload,
+  });
+  printJson(result);
+}
+
+async function issueInvoice(context, args) {
+  const options = parseArgVector(args).options;
+  if (!options.invoiceId) {
+    throw new Error("issue requires --invoice-id");
+  }
+  const result = await platformApiCall(context, "/api/agents/v1/platform/invoices/issue", {
+    method: "POST",
+    body: {
+      invoiceId: options.invoiceId,
+      seriesId: options.seriesId,
+    },
+  });
+  printJson(result);
+}
+
+async function searchEntities(context, args) {
+  const options = parseArgVector(args).options;
+  const query = new URLSearchParams();
+  if (options.query) query.set("query", options.query);
+  if (options.taxId) query.set("taxId", options.taxId);
+  if (options.limit) query.set("limit", options.limit);
+  const result = await platformApiCall(context, `/api/agents/v1/platform/entities/search?${query.toString()}`, {
+    method: "GET",
+  });
+  printJson(result);
+}
+
+async function listContacts(context, args) {
+  const options = parseArgVector(args).options;
+  const query = new URLSearchParams();
+  if (options.entityId) query.set("entityId", options.entityId);
+  if (options.name) query.set("name", options.name);
+  const result = await platformApiCall(context, `/api/agents/v1/platform/contacts/list?${query.toString()}`, {
+    method: "GET",
+  });
+  printJson(result);
+}
+

package/src/commands/session-run.js

@@ -0,0 +1,250 @@
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { parseArgVector, asBool } from "../lib/args.js";
+import { readAuthProfile } from "../lib/auth-store.js";
+import { readCliConfig } from "../lib/config-store.js";
+
+export async function runSession(args) {
+  const config = await parseConfig(args);
+  const headers = buildHeaders(config);
+  const sessionId = config.sessionId ?? await startSession(config, headers);
+  log(`session: ${sessionId}`);
+
+  const submit = await callApi(
+    `${config.runtimeUrl}/api/agents/v1/sessions/${encodeURIComponent(sessionId)}/turns`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        message: { content: config.message },
+        idempotencyKey: config.idempotencyKey,
+      }),
+    },
+    { retries: 2, retryDelayMs: 400 }
+  );
+  if (!submit.ok) {
+    throw new Error(`submitTurn failed: ${submit.error} ${submit.message ?? ""}`.trim());
+  }
+  log(`turn submitted (idempotencyKey=${config.idempotencyKey})`);
+
+  const startedAt = Date.now();
+  while (true) {
+    if (Date.now() - startedAt > config.timeoutMs) {
+      throw new Error(`timeout after ${config.timeoutMs}ms while waiting for session completion`);
+    }
+
+    const session = await getSession(config, headers, sessionId);
+    const status = session.status ?? "unknown";
+    log(`status: ${status}`);
+
+    if (status === "completed") {
+      if (session.latestReply) printReply(session.latestReply);
+      return;
+    }
+    if (status === "failed" || status === "cancelled") {
+      throw new Error(`session finished with status=${status}${session.latestReply ? ` reply="${session.latestReply}"` : ""}`);
+    }
+    if (status === "awaiting_approval" || status === "awaiting_input" || status === "awaiting_auth") {
+      if (config.nonInteractive) {
+        throw new Error(`session requires response (${status}) but --non-interactive is set`);
+      }
+      await respondToSignal(config, headers, sessionId, status, session.signals ?? [], session.latestReply);
+    }
+    await sleep(config.pollMs);
+  }
+}
+
+async function parseConfig(args) {
+  const { options } = parseArgVector(args);
+  const defaults = await readCliConfig();
+  const profile = options.profile ?? defaults.defaultProfile ?? "default";
+  const stored = await readAuthProfile(profile);
+
+  const runtimeUrl = (options.runtimeUrl ?? process.env.NAIA_RUNTIME_URL ?? defaults.runtimeUrl ?? "http://localhost:4310").replace(/\/+$/, "");
+  const organizationId = options.organizationId ?? process.env.NAIA_ORGANIZATION_ID ?? stored?.organizationId ?? "";
+  const memberId = options.memberId ?? process.env.NAIA_MEMBER_ID ?? stored?.memberId ?? "";
+  const bearerToken = options.token ?? process.env.NAIA_BEARER_TOKEN ?? stored?.token;
+  const apiKey = options.apiKey ?? process.env.NAIA_API_KEY;
+  const message = options.message ?? "";
+
+  if (!organizationId || !memberId || !message) {
+    throw new Error("missing required args: --organization-id --member-id --message (or run naia auth login first)");
+  }
+  if (!bearerToken && !apiKey) {
+    throw new Error("missing credentials: pass --token or --api-key");
+  }
+
+  return {
+    runtimeUrl,
+    organizationId,
+    memberId,
+    bearerToken,
+    apiKey,
+    message,
+    agentSlug: options.agentSlug ?? "naia",
+    channel: options.channel ?? "cli",
+    clientType: options.clientType ?? "codex-cli",
+    sessionId: options.sessionId,
+    pollMs: Number.parseInt(options.pollMs ?? "1200", 10),
+    timeoutMs: Number.parseInt(options.timeoutMs ?? "180000", 10),
+    nonInteractive: asBool(options.nonInteractive),
+    autoApprove: asBool(options.autoApprove),
+    idempotencyKey: options.idempotencyKey ?? `cli-${randomUUID()}`,
+  };
+}
+
+function buildHeaders(config) {
+  const headers = {
+    "content-type": "application/json",
+    "x-naia-organization-id": config.organizationId,
+    "x-naia-member-id": config.memberId,
+  };
+  if (config.bearerToken) {
+    headers.authorization = `Bearer ${config.bearerToken}`;
+  } else if (config.apiKey) {
+    headers["x-api-key"] = config.apiKey;
+  }
+  return headers;
+}
+
+async function startSession(config, headers) {
+  const response = await callApi(
+    `${config.runtimeUrl}/api/agents/v1/sessions`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        agentSlug: config.agentSlug,
+        channel: config.channel,
+        clientType: config.clientType,
+      }),
+    },
+    { retries: 2, retryDelayMs: 400 }
+  );
+  if (!response.ok || !response.agentSessionId) {
+    throw new Error(`startSession failed: ${response.error} ${response.message ?? ""}`.trim());
+  }
+  return response.agentSessionId;
+}
+
+async function getSession(config, headers, sessionId) {
+  const response = await callApi(
+    `${config.runtimeUrl}/api/agents/v1/sessions/${encodeURIComponent(sessionId)}`,
+    { method: "GET", headers },
+    { retries: 1, retryDelayMs: 200 }
+  );
+  if (!response.ok) {
+    throw new Error(`getSession failed: ${response.error} ${response.message ?? ""}`.trim());
+  }
+  return response;
+}
+
+async function respondToSignal(config, headers, sessionId, status, signals, latestReply) {
+  const primarySignal = signals[0]?.type
+    ?? (status === "awaiting_approval" ? "approve_plan" : status === "awaiting_input" ? "clarify" : "auth");
+
+  if (config.autoApprove && primarySignal === "approve_plan") {
+    await postRespond(config, headers, sessionId, {
+      signal: "approve_plan",
+      decision: "approve",
+      value: "Approved from CLI auto-approve",
+    });
+    log("auto-approved pending plan");
+    return;
+  }
+
+  if (latestReply) printReply(latestReply);
+
+  const rl = createInterface({ input, output });
+  try {
+    if (primarySignal === "approve_plan") {
+      const answer = (await rl.question("Approval required. Type 'approve' or 'deny': ")).trim().toLowerCase();
+      if (answer !== "approve" && answer !== "deny") {
+        throw new Error("invalid decision, expected approve|deny");
+      }
+      await postRespond(config, headers, sessionId, {
+        signal: "approve_plan",
+        decision: answer,
+        value: answer === "approve" ? "Approved from CLI" : "Denied from CLI",
+      });
+      return;
+    }
+    if (primarySignal === "clarify" || status === "awaiting_input") {
+      const answer = (await rl.question("Input required. Write response: ")).trim();
+      if (!answer) throw new Error("empty clarify response");
+      await postRespond(config, headers, sessionId, {
+        signal: "clarify",
+        decision: "provide_input",
+        value: answer,
+      });
+      return;
+    }
+    const answer = (await rl.question("Auth/selection required. Type 'resume' or 'stop': ")).trim().toLowerCase();
+    if (answer !== "resume" && answer !== "stop") {
+      throw new Error("invalid decision, expected resume|stop");
+    }
+    await postRespond(config, headers, sessionId, {
+      signal: answer,
+      decision: answer,
+      value: answer === "resume" ? "Continue from CLI" : "Stop from CLI",
+    });
+  } finally {
+    rl.close();
+  }
+}
+
+async function postRespond(config, headers, sessionId, payload) {
+  const response = await callApi(
+    `${config.runtimeUrl}/api/agents/v1/sessions/${encodeURIComponent(sessionId)}/respond`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+    },
+    { retries: 1, retryDelayMs: 200 }
+  );
+  if (!response.ok) {
+    throw new Error(`respond failed: ${response.error} ${response.message ?? ""}`.trim());
+  }
+}
+
+async function callApi(url, init, retry) {
+  let attempt = 0;
+  while (true) {
+    try {
+      const response = await fetch(url, init);
+      const json = await response.json();
+      if (response.ok) return json;
+      if (attempt < retry.retries && (response.status >= 500 || json?.retryable)) {
+        attempt += 1;
+        await sleep(retry.retryDelayMs * attempt);
+        continue;
+      }
+      return json;
+    } catch (error) {
+      if (attempt < retry.retries) {
+        attempt += 1;
+        await sleep(retry.retryDelayMs * attempt);
+        continue;
+      }
+      return { ok: false, error: "runtime_error", message: error instanceof Error ? error.message : "Unknown network error" };
+    }
+  }
+}
+
+function printReply(reply) {
+  console.log("\n--- latest reply ---");
+  console.log(reply);
+  console.log("--------------------\n");
+}
+
+function log(message) {
+  const timestamp = new Date().toISOString();
+  console.log(`[${timestamp}] ${message}`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+

package/src/lib/args.js

@@ -0,0 +1,24 @@
+export function parseArgVector(args) {
+  const options = {};
+  const positionals = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    const key = token.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    const next = args[index + 1];
+    if (next && !next.startsWith("--")) {
+      options[key] = next;
+      index += 1;
+    } else {
+      options[key] = "true";
+    }
+  }
+  return { options, positionals };
+}
+
+export function asBool(input) {
+  return input === "true" || input === "1" || input === "yes";
+}

package/src/lib/auth-store.js

@@ -0,0 +1,49 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export function getAuthStorePath() {
+  return join(homedir(), ".config", "naia", "cli-auth.json");
+}
+
+export async function readAuthProfile(profile = "default") {
+  const filePath = getAuthStorePath();
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const resolvedProfile = profile === "default"
+      ? (parsed.defaultProfile || "default")
+      : profile;
+    const item = parsed.profiles?.[resolvedProfile];
+    if (!item?.token || !item.organizationId || !item.memberId) {
+      return null;
+    }
+    return item;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeAuthProfile(input) {
+  const filePath = getAuthStorePath();
+  const profile = input.profile ?? "default";
+  const existing = await readStore(filePath);
+  const next = {
+    defaultProfile: existing?.defaultProfile || profile,
+    profiles: {
+      ...(existing?.profiles ?? {}),
+      [profile]: input.data,
+    },
+  };
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(next, null, 2), { mode: 0o600 });
+}
+
+async function readStore(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}