@mixmake/cli 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# MixMake CLI (MVP)
+
+Thin wrapper around MixMake MCP for the happy path.
+
+## Run locally
+
+```bash
+node cli/src/index.js doctor
+```
+
+## Commands
+
+```bash
+mixmake doctor
+mixmake key --email you@example.com
+mixmake transcribe --audio-url https://example.com/file.mp3
+mixmake transcribe --audio-id <audio_id>
+mixmake edit --transcript-id <id> --delete id1,id2,id3
+mixmake render --transcript-id <id>
+```
+
+## Config
+
+Saved at:
+
+`~/.config/mixmake/config.json`
+
+Shape:
+
+```json
+{
+  "endpoint": "https://mixmake.com/api/mcp",
+  "apiKey": "mmk_..."
+}
+```
+
+Environment overrides:
+
+- `MIXMAKE_MCP_URL`
+- `MIXMAKE_API_KEY`

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@mixmake/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MixMake CLI for MCP happy-path workflows",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swappysh/mixmake.git",
+    "directory": "cli"
+  },
+  "homepage": "https://mixmake.com/for-agents",
+  "bin": {
+    "mixmake": "src/index.js"
+  },
+  "scripts": {
+    "start": "node ./src/index.js",
+    "doctor": "node ./src/index.js doctor"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/config.js

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_ENDPOINT = 'https://mixmake.com/api/mcp';
+const CONFIG_DIR = path.join(homedir(), '.config', 'mixmake');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+export async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      endpoint: parsed.endpoint || DEFAULT_ENDPOINT,
+      apiKey: parsed.apiKey || null,
+    };
+  } catch {
+    return {
+      endpoint: DEFAULT_ENDPOINT,
+      apiKey: null,
+    };
+  }
+}
+
+export async function saveConfig(next) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+
+export function withEnvOverrides(config) {
+  return {
+    endpoint: process.env.MIXMAKE_MCP_URL || config.endpoint,
+    apiKey: process.env.MIXMAKE_API_KEY || config.apiKey,
+  };
+}
+
+export function getConfigPath() {
+  return CONFIG_PATH;
+}

package/src/index.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { callTool, extractToolText, initialize } from './mcpClient.js';
+import { getConfigPath, loadConfig, saveConfig, withEnvOverrides } from './config.js';
+
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const cur = argv[i];
+    if (!cur.startsWith('--')) {
+      positionals.push(cur);
+      continue;
+    }
+    const key = cur.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return { positionals, flags };
+}
+
+function usage() {
+  console.log(`mixmake <command> [flags]
+
+Commands:
+  doctor
+  key --email <email>
+  transcribe --audio-url <url> | --audio-id <id> [--label <label>]
+  edit --transcript-id <id> --delete <id1,id2,...>
+  render --transcript-id <id>
+
+Config:
+  ${getConfigPath()}
+Environment overrides:
+  MIXMAKE_MCP_URL, MIXMAKE_API_KEY
+`);
+}
+
+function printResult(label, data) {
+  console.log(`\n${label}:`);
+  console.log(JSON.stringify(data, null, 2));
+}
+
+async function main() {
+  const { positionals, flags } = parseArgs(process.argv.slice(2));
+  const cmd = positionals[0];
+  if (!cmd || cmd === 'help' || cmd === '--help') {
+    usage();
+    process.exit(0);
+  }
+
+  const config = withEnvOverrides(await loadConfig());
+  const endpoint = config.endpoint;
+
+  if (cmd === 'doctor') {
+    const init = await initialize(endpoint);
+    printResult('doctor', {
+      ok: true,
+      endpoint,
+      session_id: init.sessionId,
+      request_id: init.requestId || null,
+      server_info: init.payload?.result?.serverInfo || null,
+      timestamp: new Date().toISOString(),
+    });
+    return;
+  }
+
+  if (cmd === 'key') {
+    const email = flags.email;
+    if (!email || typeof email !== 'string') throw new Error('--email is required');
+    const init = await initialize(endpoint);
+    const out = await callTool({
+      endpoint,
+      sessionId: init.sessionId,
+      token: init.token,
+      apiKey: config.apiKey,
+      name: 'get_api_key',
+      args: { email },
+    });
+    const text = extractToolText(out.payload);
+    printResult('get_api_key', text ? JSON.parse(text) : out.payload);
+
+    try {
+      const parsed = text ? JSON.parse(text) : null;
+      const key = parsed?.api_key || parsed?.key || null;
+      if (key && !process.env.MIXMAKE_API_KEY) {
+        await saveConfig({ endpoint, apiKey: key });
+        console.log(`\nSaved api_key to ${getConfigPath()}`);
+      }
+    } catch {
+      // no-op: only auto-save if response shape is predictable JSON
+    }
+    return;
+  }
+
+  if (cmd === 'transcribe') {
+    const audioUrl = flags['audio-url'];
+    const audioId = flags['audio-id'];
+    const label = flags.label;
+    if (!audioUrl && !audioId) throw new Error('Provide --audio-url or --audio-id');
+    const init = await initialize(endpoint);
+    const out = await callTool({
+      endpoint,
+      sessionId: init.sessionId,
+      token: init.token,
+      apiKey: config.apiKey,
+      name: 'transcribe_audio',
+      args: { audio_url: audioUrl, audio_id: audioId, label },
+    });
+    const text = extractToolText(out.payload);
+    printResult('transcribe_audio', text ? JSON.parse(text) : out.payload);
+    return;
+  }
+
+  if (cmd === 'edit') {
+    const transcriptId = flags['transcript-id'];
+    const deleted = flags.delete;
+    if (!transcriptId || typeof transcriptId !== 'string') throw new Error('--transcript-id is required');
+    if (!deleted || typeof deleted !== 'string') throw new Error('--delete is required (comma-separated)');
+    const deletedIds = deleted
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const init = await initialize(endpoint);
+    const out = await callTool({
+      endpoint,
+      sessionId: init.sessionId,
+      token: init.token,
+      apiKey: config.apiKey,
+      name: 'edit_transcript',
+      args: { transcript_id: transcriptId, deleted_ids: deletedIds },
+    });
+    const text = extractToolText(out.payload);
+    printResult('edit_transcript', text ? JSON.parse(text) : out.payload);
+    return;
+  }
+
+  if (cmd === 'render') {
+    const transcriptId = flags['transcript-id'];
+    if (!transcriptId || typeof transcriptId !== 'string') throw new Error('--transcript-id is required');
+    const init = await initialize(endpoint);
+    const out = await callTool({
+      endpoint,
+      sessionId: init.sessionId,
+      token: init.token,
+      apiKey: config.apiKey,
+      name: 'render_audio',
+      args: { transcript_id: transcriptId },
+    });
+    const text = extractToolText(out.payload);
+    printResult('render_audio', text ? JSON.parse(text) : out.payload);
+    return;
+  }
+
+  throw new Error(`Unknown command: ${cmd}`);
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/src/mcpClient.js

@@ -0,0 +1,90 @@
+const ACCEPT = 'application/json, text/event-stream';
+
+function stripTrailingSlash(url) {
+  return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+
+function headers(base = {}) {
+  return {
+    Accept: ACCEPT,
+    'Content-Type': 'application/json',
+    ...base,
+  };
+}
+
+export async function initialize(endpoint) {
+  const body = {
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2025-03-26',
+      capabilities: {},
+      clientInfo: { name: 'mixmake-cli', version: '0.1.0' },
+    },
+  };
+
+  const res = await fetch(stripTrailingSlash(endpoint), {
+    method: 'POST',
+    headers: headers(),
+    body: JSON.stringify(body),
+    redirect: 'follow',
+  });
+
+  const requestId = res.headers.get('x-request-id');
+  const sessionId = res.headers.get('mcp-session-id') || res.headers.get('Mcp-Session-Id');
+  const payload = await safeJson(res);
+  const token = payload?.result?._meta?.sessionToken;
+
+  if (!res.ok) {
+    throw new Error(`initialize failed (${res.status})${requestId ? ` request_id=${requestId}` : ''}`);
+  }
+  if (!sessionId || !token) {
+    throw new Error(`initialize missing session details${requestId ? ` request_id=${requestId}` : ''}`);
+  }
+  return { sessionId, token, requestId, payload };
+}
+
+export async function callTool({ endpoint, sessionId, token, apiKey, name, args, id = 2 }) {
+  const body = {
+    jsonrpc: '2.0',
+    id,
+    method: 'tools/call',
+    params: {
+      name,
+      arguments: args,
+    },
+  };
+  const extraHeaders = {
+    Authorization: `Bearer ${token}`,
+    'Mcp-Session-Id': sessionId,
+  };
+  if (apiKey) extraHeaders['X-Mixmake-Api-Key'] = apiKey;
+
+  const res = await fetch(stripTrailingSlash(endpoint), {
+    method: 'POST',
+    headers: headers(extraHeaders),
+    body: JSON.stringify(body),
+    redirect: 'follow',
+  });
+  const requestId = res.headers.get('x-request-id');
+  const payload = await safeJson(res);
+  if (!res.ok) {
+    throw new Error(`tool ${name} failed (${res.status})${requestId ? ` request_id=${requestId}` : ''}`);
+  }
+  if (payload?.error) {
+    const msg = payload.error?.message || 'unknown error';
+    throw new Error(`tool ${name} error: ${msg}${requestId ? ` request_id=${requestId}` : ''}`);
+  }
+  return { payload, requestId };
+}
+
+function safeJson(res) {
+  return res
+    .json()
+    .catch(async () => ({ raw: await res.text().catch(() => ''), error: { message: 'non-json response' } }));
+}
+
+export function extractToolText(payload) {
+  return payload?.result?.content?.find?.((item) => item.type === 'text')?.text;
+}