faceless-cli 1.0.0

package/src/mcp/stdio.mjs

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { resolveApiKey, resolveBaseUrl } from "../config.mjs";
+import { CliError, request } from "../client.mjs";
+
+const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+let spec;
+try {
+  spec = JSON.parse(
+    fs.readFileSync(new URL("../generated/operations.json", import.meta.url), "utf8")
+  );
+} catch {
+  throw new Error(
+    'cli/src/generated/operations.json is missing. Run "npm run generate:agents" in the repo root to generate it.'
+  );
+}
+const operations = spec.operations.filter((op) => op.mcp && op.mcp.enabled);
+
+function toolInputSchema(op) {
+  const properties = {
+    ...((op.querySchema && op.querySchema.properties) || {}),
+    ...((op.requestSchema && op.requestSchema.properties) || {}),
+  };
+  const required = [
+    ...new Set([
+      ...((op.querySchema && op.querySchema.required) || []),
+      ...((op.requestSchema && op.requestSchema.required) || []),
+    ]),
+  ];
+  const schema = { type: "object", properties, additionalProperties: false };
+  if (required.length) schema.required = required;
+  return schema;
+}
+
+function errorResult(type, message) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ success: false, error: { type, message } }),
+      },
+    ],
+  };
+}
+
+export async function runMcpServer() {
+  const server = new Server(
+    { name: "faceless", version: pkg.version },
+    { capabilities: { tools: {} } }
+  );
+
+  const tools = operations.map((op) => ({
+    name: op.mcp.name,
+    description: `${op.summary}. ${op.description}`,
+    inputSchema: toolInputSchema(op),
+  }));
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = { ...(req.params.arguments || {}) };
+    const op = operations.find((o) => o.mcp.name === name);
+    if (!op) return errorResult("invalid_input", `Unknown tool: ${name}`);
+
+    const apiKey = resolveApiKey({});
+    if (!apiKey) {
+      return errorResult(
+        "unauthorized",
+        'No API key configured. Set the FACELESS_API_KEY environment variable or run "faceless login". Create keys in your team settings at https://faceless.so/team.'
+      );
+    }
+
+    let path = op.path;
+    for (const match of op.path.matchAll(/\{(\w+)\}/g)) {
+      const param = match[1];
+      if (args[param] === undefined || args[param] === null) {
+        return errorResult("invalid_input", `Missing required parameter: ${param}`);
+      }
+      path = path.replace(`{${param}}`, encodeURIComponent(String(args[param])));
+      delete args[param];
+    }
+
+    try {
+      const method = op.method.toLowerCase();
+      const hasBody = method !== "get" && method !== "delete";
+      // Transport-level replay key (same semantics as the HTTP Idempotency-Key
+      // header and the remote MCP's idempotencyKey argument), not operation input.
+      const { idempotencyKey, ...opArgs } = args;
+      const result = await request({
+        method: op.method,
+        path,
+        query: hasBody ? undefined : opArgs,
+        body: hasBody ? opArgs : undefined,
+        apiKey,
+        baseUrl: resolveBaseUrl({}),
+        idempotencyKey,
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      if (err instanceof CliError) return errorResult(err.type, err.message);
+      return errorResult("internal_error", err.message || "Unknown error");
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/output.mjs

@@ -0,0 +1,109 @@
+const PREFERRED_COLUMNS = [
+  "id",
+  "name",
+  "platform",
+  "channelName",
+  "username",
+  "status",
+  "renderStatus",
+  "model",
+  "source",
+  "niche",
+  "type",
+  "credits",
+  "paused",
+  "scheduledTime",
+  "postedAt",
+  "createdAt",
+  "value",
+  "label",
+];
+
+const MAX_COLUMNS = 6;
+const MAX_CELL = 40;
+
+function cell(value) {
+  if (value === undefined || value === null) return "";
+  const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+  const flat = text.replace(/\s+/g, " ");
+  return flat.length > MAX_CELL ? flat.slice(0, MAX_CELL - 3) + "..." : flat;
+}
+
+function pickColumns(rows) {
+  const keys = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!keys.includes(key)) keys.push(key);
+    }
+  }
+  const preferred = PREFERRED_COLUMNS.filter((key) => keys.includes(key));
+  const rest = keys.filter((key) => !preferred.includes(key));
+  return [...preferred, ...rest].slice(0, MAX_COLUMNS);
+}
+
+function printTable(rows, indent = "") {
+  if (!rows.length) {
+    process.stdout.write(indent + "(no results)\n");
+    return;
+  }
+  if (rows.some((row) => !row || typeof row !== "object")) {
+    for (const row of rows) process.stdout.write(indent + cell(row) + "\n");
+    return;
+  }
+  const columns = pickColumns(rows);
+  const widths = columns.map((col) =>
+    Math.max(col.length, ...rows.map((row) => cell(row[col]).length))
+  );
+  const line = (values) =>
+    indent + values.map((value, i) => String(value).padEnd(widths[i])).join("  ") + "\n";
+  process.stdout.write(line(columns));
+  process.stdout.write(line(widths.map((w) => "-".repeat(w))));
+  for (const row of rows) {
+    process.stdout.write(line(columns.map((col) => cell(row[col]))));
+  }
+}
+
+function printObject(obj, indent = "") {
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) {
+      if (value.length && value.every((v) => v && typeof v === "object")) {
+        process.stdout.write(`${indent}${key}:\n`);
+        printTable(value, indent + "  ");
+      } else {
+        process.stdout.write(`${indent}${key}: ${value.map(cell).join(", ")}\n`);
+      }
+    } else if (value && typeof value === "object") {
+      process.stdout.write(`${indent}${key}:\n`);
+      printObject(value, indent + "  ");
+    } else {
+      process.stdout.write(`${indent}${key}: ${value}\n`);
+    }
+  }
+}
+
+export function print(result, { json = false } = {}) {
+  if (json || !process.stdout.isTTY) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  const data = result && typeof result === "object" && "data" in result ? result.data : result;
+  if (Array.isArray(data)) {
+    printTable(data);
+  } else if (data && typeof data === "object") {
+    printObject(data);
+  } else {
+    process.stdout.write(String(data) + "\n");
+  }
+  if (result && typeof result === "object" && result.pagination) {
+    const p = result.pagination;
+    const pages = p.pages || (p.limit ? Math.ceil((p.total || 0) / p.limit) : undefined);
+    process.stdout.write(`page ${p.page}${pages ? ` of ${pages}` : ""} (${p.total} total)\n`);
+  }
+}
+
+export function printError(err) {
+  const type = (err && err.type) || "internal_error";
+  const message = (err && err.message) || "Unknown error";
+  process.stderr.write(`error (${type}): ${message}\n`);
+}