mcp.h File Reference

Go to the source code of this file.

Data Structures
struct	mcp_policy_t
struct	mcp_job
	When code needs to work with mcp policy, it keeps hosted, restricted, address, address6 here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. More...
struct	mcp_server
	The useful part of mcp job is in server, message, response, request: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. More...

Macros
#define	MCP_SERVER_MCP_ERROR_BUFFER_SIZE   2048
#define	MCP_MAX_INPUT   (24u * 1024u * 1024u)
#define	MCP_MAX_OUTPUT   (8u * 1024u * 1024u)
#define	MCP_MAX_DOWNLOAD   (64u * 1024u * 1024u)
#define	MCP_SESSION_ID_LENGTH   32

Typedefs
typedef struct mcp_job	mcp_job_t
	When code needs to work with mcp policy, it keeps hosted, restricted, address, address6 here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields.
typedef struct mcp_server	mcp_server_t
	The useful part of mcp job is in server, message, response, request: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

Enumerations
enum	mcp_tool_t { MCP_FILE , MCP_URL , MCP_WEBCAM , MCP_VISUALIZATION }

Functions
int	mcp_server_main (void)
asciichat_error_t	mcp_stdio_reserve (void)
void	mcp_stdio_release (void)
yyjson_mut_val *	mcp_tools_schema (yyjson_mut_doc *doc, const mcp_policy_t *policy)
asciichat_error_t	mcp_request_parse (const mcp_policy_t *policy, mcp_tool_t tool, yyjson_val *arguments, http_renderer_process_request_t *out)
void	mcp_request_destroy (http_renderer_process_request_t *request)
yyjson_mut_doc *	mcp_dispatch (mcp_server_t *server, yyjson_doc *message, void *connection, const char *session_id, bool *pending)
yyjson_mut_doc *	mcp_error (yyjson_val *id, int code, const char *message)
void	mcp_jobs_reap (mcp_server_t *server, bool all)
void	mcp_stdio_send (mcp_server_t *server, yyjson_mut_doc *response)
asciichat_error_t	mcp_stdio_run (mcp_server_t *server)
asciichat_error_t	mcp_http_run (mcp_server_t *server)
void	mcp_http_wake (mcp_server_t *server)
const char *	mcp_output_mime (const char *extension)
bool	mcp_download_name (const char *name, int64_t *expires)
void	mcp_download_prune (const char *directory, int64_t now)
asciichat_error_t	mcp_download_finalize (const mcp_policy_t *policy, yyjson_mut_doc *doc, int64_t now)

Variables
const char *const	mcp_output_formats []

Macro Definition Documentation

MCP_MAX_DOWNLOAD

#define MCP_MAX_DOWNLOAD   (64u * 1024u * 1024u)

Definition at line 31 of file mcp.h.

Referenced by mcp_http_run().

MCP_MAX_INPUT

#define MCP_MAX_INPUT   (24u * 1024u * 1024u)

Definition at line 29 of file mcp.h.

Referenced by mcp_http_run(), and mcp_stdio_run().

MCP_MAX_OUTPUT

#define MCP_MAX_OUTPUT   (8u * 1024u * 1024u)

Definition at line 30 of file mcp.h.

MCP_SERVER_MCP_ERROR_BUFFER_SIZE

#define MCP_SERVER_MCP_ERROR_BUFFER_SIZE   2048

Definition at line 4 of file mcp.h.

MCP_SESSION_ID_LENGTH

#define MCP_SESSION_ID_LENGTH   32

Definition at line 32 of file mcp.h.

Typedef Documentation

mcp_job_t

typedef struct mcp_job mcp_job_t

When code needs to work with mcp policy, it keeps hosted, restricted, address, address6 here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields.

For mcp render result, this is the live record that ties text, length, elapsed_ms, timed_out together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record.

mcp_server_t

typedef struct mcp_server mcp_server_t

The useful part of mcp job is in server, message, response, request: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

mcp server keeps the values that move through the subsystem: policy, jobs, output_mutex, shared_http. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself.

Enumeration Type Documentation

mcp_tool_t

enum mcp_tool_t

Enumerator
MCP_FILE
MCP_URL
MCP_WEBCAM
MCP_VISUALIZATION

Definition at line 34 of file mcp.h.

{ MCP_FILE, MCP_URL, MCP_WEBCAM, MCP_VISUALIZATION } mcp_tool_t;

Function Documentation

mcp_dispatch()

yyjson_mut_doc * mcp_dispatch	(	mcp_server_t *	server,
		yyjson_doc *	message,
		void *	connection,
		const char *	session_id,
		bool *	pending )

Definition at line 222 of file mcp-server/protocol.c.

                                            {
  ASCII_OTEL_SCOPE(MCP_REQUEST);
  ASCII_OTEL_ATTR_STRING("rpc.system", "jsonrpc");
  ASCII_OTEL_ATTR_STRING("mcp.transport", s->policy.hosted ? "http" : "stdio");
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REQUESTS, 1);
  *pending = false;
  yyjson_val *root = yyjson_doc_get_root(message), *id = mcp_get(root, "id"), *method = mcp_get(root, "method"),
             *version = mcp_get(root, "jsonrpc");
  if (!yyjson_is_obj(root) || !yyjson_is_str(version) || strcmp(yyjson_get_str(version), "2.0") ||
      !yyjson_is_str(method) || strlen(yyjson_get_str(method)) != yyjson_get_len(method) ||
      (id && !yyjson_is_str(id) && !yyjson_is_int(id)))
    return mcp_error(id, -32600, "Invalid JSON-RPC request");
  const char *name = yyjson_get_str(method);
  static const char *const methods[] = {
      "initialize", "ping", "tools/list", "tools/call", "notifications/initialized", "notifications/cancelled"};
  const char *method_name = "unknown";
  for (size_t i = 0; i < sizeof(methods) / sizeof(methods[0]); i++)
    if (!strcmp(name, methods[i]))
      method_name = methods[i];
  ASCII_OTEL_ATTR_STRING("rpc.method", method_name);
  yyjson_val *params = mcp_get(root, "params");
  if (params && !yyjson_is_obj(params))
    return id ? mcp_error(id, -32602, "params must be an object") : NULL;
  if (!id) {
    if (!strcmp(name, "notifications/initialized"))
      s->initialized = true;
    if (!strcmp(name, "notifications/cancelled")) {
      yyjson_val *cancel = mcp_get(params, "requestId");
      for (unsigned i = 0; i < s->policy.max_jobs; ++i)
        if (s->jobs[i].renderer_job.started &&
            (!s->policy.hosted || (session_id && *session_id && !strcmp(s->jobs[i].session_id, session_id)) ||
             ((!session_id || !*session_id) && s->jobs[i].connection == connection)) &&
            same_id(cancel, mcp_get(yyjson_doc_get_root(s->jobs[i].message), "id")))
          http_renderer_job_cancel(&s->jobs[i].renderer_job);
    }
    return NULL;
  }
  yyjson_mut_doc *d = envelope(id);
  yyjson_mut_val *result = yyjson_mut_obj(d);
  yyjson_mut_obj_add_val(d, yyjson_mut_doc_get_root(d), "result", result);
  if (!strcmp(name, "initialize")) {
    yyjson_val *requested = mcp_get(params, "protocolVersion");
    const char *v = yyjson_get_str(requested);
    if (!v || (strcmp(v, "2025-11-25") && strcmp(v, "2025-06-18") && strcmp(v, "2025-03-26")))
      v = "2025-11-25";
    yyjson_mut_obj_add_strcpy(d, result, "protocolVersion", v);
    yyjson_mut_val *caps = yyjson_mut_obj(d), *info = yyjson_mut_obj(d);
    yyjson_mut_obj_add_val(d, caps, "tools", yyjson_mut_obj(d));
    yyjson_mut_obj_add_val(d, result, "capabilities", caps);
    yyjson_mut_obj_add_str(d, info, "name", "ascii-chat");
    yyjson_mut_obj_add_str(d, info, "version", ASCII_CHAT_VERSION_FULL);
    yyjson_mut_obj_add_val(d, result, "serverInfo", info);
    const char *instructions =
        s->policy.restricted && s->policy.hosted
            ? "Render uploaded bytes or HTTP(S) media URLs as ASCII art. The hosted server cannot access your webcam "
              "or "
              "local filesystem. Rendered files are returned as temporary download links with UTC expiration "
              "timestamps; "
              "links expire after 30 minutes. Use output_format to select the file format, snapshot-delay to set clip "
              "duration, and options.audio=true to include source audio."
            : "Render media as ASCII art. Uploaded bytes must be base64 encoded by the client. snapshot-delay measures "
              "capture duration after the first rendered frame; use seek for media timestamps. output_path saves ASCII "
              "art "
              "as an image/video and never replaces an existing file.";
    yyjson_mut_obj_add_str(d, result, "instructions", instructions);
    return d;
  }
  if (!strcmp(name, "ping"))
    return d;
  if (!strcmp(name, "tools/list")) {
    yyjson_mut_obj_add_val(d, result, "tools", mcp_tools_schema(d, &s->policy));
    return d;
  }
  yyjson_mut_doc_free(d);
  if (strcmp(name, "tools/call"))
    return mcp_error(id, -32601, "Method not found");
  const char *tool = yyjson_get_str(mcp_get(params, "name"));
  if (tool && yyjson_get_len(mcp_get(params, "name")) == sizeof("device_list") - 1 && !strcmp(tool, "device_list")) {
    if (s->policy.restricted)
      return mcp_error(id, -32602, "Unknown tool");
    ASCII_OTEL_ATTR_STRING("mcp.tool", "device_list");
    return device_list_result(id, mcp_get(params, "arguments"));
  }
  const char *names[] = {"render_file", "render_url", "render_webcam", "render_visualization"};
  int kind = -1;
  for (int i = 0; i < 4; ++i)
    if (tool && strlen(tool) == yyjson_get_len(mcp_get(params, "name")) && !strcmp(tool, names[i]))
      kind = i;
  if (kind < 0 || (s->policy.restricted && kind == MCP_WEBCAM))
    return mcp_error(id, -32602, "Unknown tool");
  mcp_jobs_reap(s, false);
  mcp_job_t *j = NULL;
  for (unsigned i = 0; i < s->policy.max_jobs; ++i)
    if (!s->jobs[i].renderer_job.started) {
      j = &s->jobs[i];
      break;
    }
  if (!j) {
    char message[128];
    safe_snprintf(message, sizeof(message), "Server busy; at most %u render%s may run concurrently", s->policy.max_jobs,
                  s->policy.max_jobs == 1 ? "" : "s");
    return mcp_error(id, -32000, message);
  }
  yyjson_val *arguments = mcp_get(params, "arguments");
  yyjson_doc *empty = NULL;
  if (!arguments) {
    empty = yyjson_read("{}", 2, 0);
    arguments = yyjson_doc_get_root(empty);
  }
  asciichat_error_t err = mcp_request_parse(&s->policy, (mcp_tool_t)kind, arguments, &j->request);
  if (empty)
    yyjson_doc_free(empty);
  if (err != ASCIICHAT_OK) {
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REJECTED, 1);
    ASCII_OTEL_ATTR_STRING("error.type", "invalid_arguments");
    asciichat_error_context_t ctx;
    http_renderer_process_result_t fail = {0};
    SAFE_STRNCPY(fail.error, HAS_ERRNO(&ctx) ? ctx.context_message : "Invalid render request", sizeof(fail.error));
    mcp_request_destroy(&j->request);
    return tool_result(id, &fail);
  }
  // Copy before returning to the transport, which owns and frees the input document.
  size_t len;
  char *copy = yyjson_write(message, 0, &len);
  j->message = yyjson_read(copy, len, 0);
  free(copy);
  j->tool = (mcp_tool_t)kind;
  j->telemetry_parent = ascii_otel_context();
  j->server = s;
  j->connection = connection;
  if (session_id)
    SAFE_STRNCPY(j->session_id, session_id, sizeof(j->session_id));
  if (http_renderer_job_start(&j->renderer_job, "mcp-render", run_job, j) != ASCIICHAT_OK) {
    mcp_request_destroy(&j->request);
    yyjson_doc_free(j->message);
    memset(j, 0, sizeof(*j));
    return mcp_error(id, -32603, "Cannot create render worker");
  }
  *pending = true;
  return NULL;
}

References ASCII_OTEL_ATTR_STRING, ascii_otel_context(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, mcp_job::connection, asciichat_error_context_t::context_message, http_renderer_process_result_t::error, HAS_ERRNO, mcp_policy_t::hosted, http_renderer_job_cancel(), http_renderer_job_start(), mcp_server::initialized, mcp_server::jobs, mcp_policy_t::max_jobs, mcp_error(), mcp_jobs_reap(), mcp_request_destroy(), mcp_request_parse(), mcp_tools_schema(), MCP_WEBCAM, mcp_job::message, mcp_server::policy, mcp_job::renderer_job, mcp_job::request, mcp_policy_t::restricted, safe_snprintf(), SAFE_STRNCPY, mcp_job::server, mcp_job::session_id, session_id, http_renderer_job::started, stats_counter_add(), STATS_COUNTER_MCP_REJECTED, STATS_COUNTER_MCP_REQUESTS, stats_runtime_scope(), mcp_job::telemetry_parent, and mcp_job::tool.

Referenced by mcp_stdio_run().

mcp_download_finalize()

asciichat_error_t mcp_download_finalize	(	const mcp_policy_t *	policy,
		yyjson_mut_doc *	doc,
		int64_t	now )

Definition at line 74 of file downloads.c.

                                                                                                      {
  yyjson_mut_val *result = yyjson_mut_obj_get(yyjson_mut_doc_get_root(doc), "result");
  yyjson_mut_val *data = yyjson_mut_obj_get(result, "structuredContent");
  yyjson_mut_val *files = yyjson_mut_obj_get(data, "saved_files");
  yyjson_mut_val *first = yyjson_mut_arr_get_first(files);
  const char *old = yyjson_mut_get_str(first);
  if (!old || !*old)
    return ASCIICHAT_OK;
  const char *name = strrchr(old, '/');
  const char *back = strrchr(old, '\\');
  if (back && (!name || back > name))
    name = back;
  name = name ? name + 1 : old;
  int64_t ignored;
  if (!mcp_download_name(name, &ignored))
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid generated download name");
  const char *token = strchr(name, '-');
  int64_t expires = now + 1800;
  char new_name[128], new_path[PLATFORM_MAX_PATH_LENGTH], url[PLATFORM_MAX_PATH_LENGTH * 2];
  int n = safe_snprintf(new_name, sizeof(new_name), "%lld%s", (long long)expires, token);
  if (n < 0 || (size_t)n >= sizeof(new_name))
    return SET_ERRNO(ERROR_INVALID_STATE, "Download name is too long");
  n = safe_snprintf(new_path, sizeof(new_path), "%s/%s", policy->downloads_dir, new_name);
  if (n < 0 || (size_t)n >= sizeof(new_path))
    return SET_ERRNO(ERROR_INVALID_STATE, "Download path is too long");
  const char *prefix = policy->downloads_url_prefix;
  char fallback[128];
  if (!prefix || !*prefix) {
    SAFE_SNPRINTF(fallback, sizeof(fallback), "%s://127.0.0.1:%d",
                  policy->tls_cert && *policy->tls_cert ? "https" : "http", policy->port);
    prefix = fallback;
  }
  size_t prefix_len = strlen(prefix);
  n = safe_snprintf(url, sizeof(url), "%s%sdownloads/%s", prefix,
                    prefix_len && prefix[prefix_len - 1] == '/' ? "" : "/", new_name);
  if (n < 0 || (size_t)n >= sizeof(url))
    return SET_ERRNO(ERROR_INVALID_STATE, "Download URL is too long");
  if (strcmp(old, new_path)) {
    uv_fs_t fs;
    int rc = uv_fs_link(NULL, &fs, old, new_path, NULL);
    uv_fs_req_cleanup(&fs);
    if (rc < 0)
      return SET_ERRNO(ERROR_FILE_OPERATION, "Cannot publish download: %s", uv_strerror(rc));
    uv_fs_unlink(NULL, &fs, old, NULL);
    uv_fs_req_cleanup(&fs);
  }
  time_t t = (time_t)expires;
  struct tm utc;
  char timestamp[32];
  if (platform_gtime(&t, &utc) != ASCIICHAT_OK || !strftime(timestamp, sizeof(timestamp), "%Y-%m-%dT%H:%M:%SZ", &utc))
    return SET_ERRNO(ERROR_INVALID_STATE, "Cannot format download expiration");
  yyjson_mut_arr_clear(files);
  yyjson_mut_arr_add_strcpy(doc, files, url);
  yyjson_mut_obj_add_strcpy(doc, data, "download_url", url);
  yyjson_mut_obj_add_strcpy(doc, data, "expires_at", timestamp);
  yyjson_mut_val *content = yyjson_mut_obj_get(result, "content");
  yyjson_mut_val *item = yyjson_mut_arr_get_first(content);
  char description[sizeof(url) + 80];
  SAFE_SNPRINTF(description, sizeof(description), "Download: %s\nExpires: %s", url, timestamp);
  yyjson_mut_obj_remove_str(item, "text");
  yyjson_mut_obj_add_strcpy(doc, item, "text", description);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, mcp_policy_t::downloads_dir, mcp_policy_t::downloads_url_prefix, ERROR_FILE_OPERATION, ERROR_INVALID_STATE, mcp_download_name(), platform_gtime(), PLATFORM_MAX_PATH_LENGTH, mcp_policy_t::port, SAFE_SNPRINTF, safe_snprintf(), SET_ERRNO, and mcp_policy_t::tls_cert.

mcp_download_name()

bool mcp_download_name	(	const char *	name,
		int64_t *	expires )

Definition at line 22 of file downloads.c.

                                                           {
  if (!name || strlen(name) < 47)
    return false;
  const char *p = name;
  while (isdigit((unsigned char)*p))
    ++p;
  if (p == name || p - name > 12 || *p++ != '-')
    return false;
  const char *digits_end = p - 1;
  for (int i = 0; i < 32; ++i)
    if (!((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f')))
      return false;
    else
      ++p;
  if (*p++ != '.')
    return false;
  if (!mcp_output_mime(p))
    return false;
  char number[16];
  size_t n = (size_t)(digits_end - name);
  memcpy(number, name, n);
  number[n] = '\0';
  int64_t value = (int64_t)strtoll(number, NULL, 10);
  if (value <= 0)
    return false;
  if (expires)
    *expires = value;
  return true;
}

References mcp_output_mime().

Referenced by mcp_download_finalize(), and mcp_download_prune().

mcp_download_prune()

void mcp_download_prune	(	const char *	directory,
		int64_t	now )

Definition at line 52 of file downloads.c.

                                                            {
  uv_fs_t scan;
  if (uv_fs_scandir(NULL, &scan, directory, 0, NULL) < 0) {
    uv_fs_req_cleanup(&scan);
    return;
  }
  uv_dirent_t entry;
  while (uv_fs_scandir_next(&scan, &entry) == 0) {
    int64_t expires;
    if (!mcp_download_name(entry.name, &expires) || expires > now)
      continue;
    char path[PLATFORM_MAX_PATH_LENGTH];
    int n = safe_snprintf(path, sizeof(path), "%s/%s", directory, entry.name);
    if (n < 0 || (size_t)n >= sizeof(path))
      continue;
    uv_fs_t op;
    uv_fs_unlink(NULL, &op, path, NULL);
    uv_fs_req_cleanup(&op);
  }
  uv_fs_req_cleanup(&scan);
}

References mcp_download_name(), PLATFORM_MAX_PATH_LENGTH, and safe_snprintf().

mcp_error()

yyjson_mut_doc * mcp_error	(	yyjson_val *	id,
		int	code,
		const char *	message )

Definition at line 17 of file mcp-server/protocol.c.

                                                                         {
  ASCII_OTEL_SCOPE(MCP_PROTOCOL_ERROR);
  ASCII_OTEL_ATTR_INT("rpc.jsonrpc.error_code", code);
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_MCP_REJECTED, 1);
  ascii_otel_error("MCP protocol request rejected");
  yyjson_mut_doc *d = envelope(id);
  yyjson_mut_val *e = yyjson_mut_obj(d);
  yyjson_mut_obj_add_int(d, e, "code", code);
  yyjson_mut_obj_add_strcpy(d, e, "message", message);
  yyjson_mut_obj_add_val(d, yyjson_mut_doc_get_root(d), "error", e);
  return d;
}

References ASCII_OTEL_ATTR_INT, ascii_otel_error(), ASCII_OTEL_SCOPE, stats_counter_add(), STATS_COUNTER_MCP_REJECTED, and stats_runtime_scope().

Referenced by mcp_dispatch(), and mcp_stdio_run().

mcp_http_run()

asciichat_error_t mcp_http_run

(

mcp_server_t *

server

)

Definition at line 233 of file http.c.

                                                {
  http_server_config_t config = {.bind_address = s->policy.address,
                                 .bind_address6 = s->policy.address6,
                                 .port = (uint16_t)s->policy.port,
                                 .enable_http1 = true,
                                 .enable_http2 = true,
                                 .tls_cert_path = s->policy.tls_cert,
                                 .tls_key_path = s->policy.tls_key,
                                 .tls_key_password = s->policy.tls_password,
                                 .max_connections = s->policy.max_jobs * 4U,
                                 .max_request_body_bytes = MCP_MAX_INPUT,
                                 .max_response_body_bytes = MCP_MAX_DOWNLOAD,
                                 .on_request = shared_http_request,
                                 .on_wakeup = shared_http_wakeup,
                                 .user_data = s};
  if (!config.max_connections)
    config.max_connections = 1;
  asciichat_error_t result = http_server_init(&s->shared_http, &config);
  if (result != ASCIICHAT_OK)
    return result;
  result = http_server_start(s->shared_http);
  if (result != ASCIICHAT_OK) {
    http_server_destroy(&s->shared_http);
    return result;
  }
  nat_upnp_context_t *mapping = NULL;
  if (GET_OPTION(enable_upnp)) {
    asciichat_error_t err = nat_upnp_open((uint16_t)s->policy.port, "ascii-chat MCP", &mapping);
    if (err != ASCIICHAT_OK)
      LOG_ERRNO_IF_SET("MCP port forwarding unavailable");
  }
  while (!atomic_load_bool(&s->stopping) && !APP_CALLBACK_BOOL(should_exit)) {
    uv_sleep(16);
    mcp_jobs_reap(s, false);
    if (mapping && time_get_ns() >= mapping->refresh_at_ns) {
      asciichat_error_t err = nat_upnp_refresh(mapping);
      if (err != ASCIICHAT_OK)
        LOG_ERRNO_IF_SET("MCP mapping renewal failed");
    }
  }
  for (unsigned i = 0; i < s->policy.max_jobs; ++i)
    if (s->jobs[i].renderer_job.started)
      http_renderer_job_cancel(&s->jobs[i].renderer_job);
  http_server_stop(s->shared_http);
  http_server_destroy(&s->shared_http);
  nat_upnp_close(&mapping);
  mcp_jobs_reap(s, true);
  return ASCIICHAT_OK;
}

References mcp_policy_t::address, mcp_policy_t::address6, APP_CALLBACK_BOOL, ASCIICHAT_OK, GET_OPTION, http_renderer_job_cancel(), http_server_destroy(), http_server_init(), http_server_start(), http_server_stop(), mcp_server::jobs, LOG_ERRNO_IF_SET, http_server_config_t::max_connections, mcp_policy_t::max_jobs, mcp_jobs_reap(), MCP_MAX_DOWNLOAD, MCP_MAX_INPUT, nat_upnp_close(), nat_upnp_open(), nat_upnp_refresh(), mcp_server::policy, mcp_policy_t::port, nat_upnp_context::refresh_at_ns, mcp_job::renderer_job, mcp_server::shared_http, should_exit(), http_renderer_job::started, mcp_server::stopping, mcp_policy_t::tls_cert, mcp_policy_t::tls_key, and mcp_policy_t::tls_password.

Referenced by mcp_server_main().

mcp_http_wake()

void mcp_http_wake

(

mcp_server_t *

server

)

Definition at line 30 of file http.c.

                                    {
  if (s && s->shared_http)
    (void)http_server_wakeup(s->shared_http);
}

References http_server_wakeup(), and mcp_server::shared_http.

mcp_jobs_reap()

void mcp_jobs_reap	(	mcp_server_t *	server,
		bool	all )

Definition at line 203 of file mcp-server/protocol.c.

                                              {
  for (unsigned i = 0; i < s->policy.max_jobs; ++i) {
    mcp_job_t *j = &s->jobs[i];
    if (!j->renderer_job.started ||
        (!all && (!http_renderer_job_is_done(&j->renderer_job) || (s->policy.hosted && j->connection))))
      continue;
    http_renderer_job_join(&j->renderer_job);
    yyjson_doc_free(j->message);
    if (j->response)
      yyjson_mut_doc_free(j->response);
    memset(j, 0, sizeof(*j));
  }
}

References mcp_job::connection, mcp_policy_t::hosted, http_renderer_job_is_done(), http_renderer_job_join(), mcp_server::jobs, mcp_policy_t::max_jobs, mcp_job::message, mcp_server::policy, mcp_job::renderer_job, mcp_job::response, and http_renderer_job::started.

Referenced by mcp_dispatch(), mcp_http_run(), mcp_server_main(), and mcp_stdio_run().

mcp_output_mime()

const char * mcp_output_mime

(

const char *

extension

)

Definition at line 10 of file downloads.c.

                                                   {
  static const char *const mime[] = {"image/png",        "image/jpeg", "image/jpeg",      "image/bmp",
                                     "image/webp",       "image/gif",  "video/mp4",       "video/quicktime",
                                     "video/x-matroska", "video/webm", "video/x-msvideo", "video/x-flv",
                                     "video/ogg",        "video/ogg",  "video/3gpp"};
  for (size_t i = 0; mcp_output_formats[i]; ++i)
    if (!strcmp(extension, mcp_output_formats[i]))
      return mime[i];
  return NULL;
}

References mcp_output_formats.

Referenced by mcp_download_name(), and mcp_request_parse().

mcp_request_destroy()

void mcp_request_destroy

(

http_renderer_process_request_t *

request

)

Definition at line 678 of file request.c.

                                                             {
  for (size_t i = 0; i < r->argc; ++i)
    SAFE_FREE(r->argv[i]);
  SAFE_FREE(r->argv);
  if (r->upload_dir[0]) {
    asciichat_error_t e = platform_rmdir_recursive(r->upload_dir);
    (void)e;
  }
  if (r->stage_dir[0]) {
    asciichat_error_t e = platform_rmdir_recursive(r->stage_dir);
    (void)e;
  }
  memset(r, 0, sizeof(*r));
}

References http_renderer_process_request_t::argc, http_renderer_process_request_t::argv, SAFE_FREE, http_renderer_process_request_t::stage_dir, and http_renderer_process_request_t::upload_dir.

Referenced by mcp_dispatch().

mcp_request_parse()

asciichat_error_t mcp_request_parse	(	const mcp_policy_t *	policy,
		mcp_tool_t	tool,
		yyjson_val *	arguments,
		http_renderer_process_request_t *	out )

Definition at line 416 of file request.c.

                                                                        {
  memset(r, 0, sizeof(*r));
  r->output_type = HTTP_RENDER_OUTPUT_TEXT;
  r->options.width = 100;
  r->options.height = 40;
  r->options.color_mode = TERM_COLOR_NONE;
  r->timeout_ms = 45000;
  r->argv = SAFE_CALLOC(MCP_REQUEST_ARGV_CAPACITY, sizeof(char *), char **);
  static const char *const fields[] = {"path",         "data_base64",   "mime_type",     "url",         "video_device",
                                       "audio",        "visualization", "options",       "output_path", "timeout_ms",
                                       "audio_device", "volume",        "output_format", "output",      NULL};
  asciichat_error_t err = check_fields(a, fields);
  if (err)
    return err;
  const char *source_fields[] = {"path",  "data_base64",   "mime_type",    "url",   "video_device",
                                 "audio", "visualization", "audio_device", "volume"};
  for (size_t i = 0; i < 9; ++i) {
    bool allowed = tool == MCP_FILE ? i < 3 : tool == MCP_URL ? i == 3 : tool == MCP_WEBCAM ? i == 4 || i >= 7 : i >= 5;
    if (!allowed && mcp_get(a, source_fields[i]))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Argument %s is not valid for this tool", source_fields[i]);
  }
  if (p->restricted && (tool == MCP_WEBCAM || mcp_get(a, "path") || mcp_get(a, "output_path") ||
                        mcp_get(a, "audio_device") || mcp_get(a, "volume")))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Local capability is unavailable in server mode");
  yyjson_val *timeout = mcp_get(a, "timeout_ms");
  if (timeout) {
    if (!yyjson_is_int(timeout) || yyjson_get_sint(timeout) < 1000 || yyjson_get_sint(timeout) > 60000)
      return SET_ERRNO(ERROR_INVALID_PARAM, "timeout_ms must be 1000–60000");
    r->timeout_ms = (unsigned)yyjson_get_uint(timeout);
  }
  char exe[PLATFORM_MAX_PATH_LENGTH];
  if (!platform_get_executable_path(exe, sizeof(exe)))
    return SET_ERRNO(ERROR_FILE_OPERATION, "Cannot locate renderer executable");
  yyjson_val *opts = mcp_get(a, "options");
  if (opts && !yyjson_is_obj(opts))
    return SET_ERRNO(ERROR_INVALID_PARAM, "options must be an object");
  yyjson_val *format_value = mcp_get(a, "output_format"), *output_value = mcp_get(a, "output_path"),
             *output_mode = mcp_get(a, "output");
  if (output_mode && (!yyjson_is_str(output_mode) ||
                      (strcmp(yyjson_get_str(output_mode), "text") && strcmp(yyjson_get_str(output_mode), "files"))))
    return SET_ERRNO(ERROR_INVALID_PARAM, "output must be text or files");
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "text") && output_value)
    return SET_ERRNO(ERROR_INVALID_PARAM, "output=text cannot be combined with output_path");
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "files"))
    r->output_type = HTTP_RENDER_OUTPUT_FILE;
  const char *output_name = yyjson_is_str(output_value) ? yyjson_get_str(output_value) : "";
  const char *output_ext = strrchr(output_name, '.');
  bool gif_requested = yyjson_is_str(format_value) && !strcmp(yyjson_get_str(format_value), "gif");
  bool gif_path = output_ext && !strcmp(output_ext, ".gif");
  bool gif_output = gif_requested || gif_path;
  bool media_tool = tool == MCP_URL || tool == MCP_FILE;
  bool media_source = mcp_get(a, "url") || mcp_get(a, "path") || mcp_get(a, "data_base64");
  bool snapshot_requested = mcp_get(opts, "snapshot") || mcp_get(opts, "snapshot-delay");
  bool gif_auto = gif_output && media_tool && media_source && !snapshot_requested;
  arg(r, exe);
  arg(r, "--log-level=error");
  arg(r, "--no-check-update");
  arg(r, "mirror");
  option(r, "width", "100");
  option(r, "height", "40");
  option(r, "color-mode", "none");
  option(r, "strip-ansi", "true");
  option(r, "snapshot", gif_auto ? "false" : "true");
  if (!gif_auto && !yyjson_is_false(mcp_get(opts, "snapshot")))
    option(r, "snapshot-delay", "0");
  option(r, "splash-screen", "false");
  option(r, "no-audio-playback", "true");
  option(r, "audio", "false");
  size_t i, max;
  yyjson_val *k, *v;
  if (opts)
    yyjson_obj_foreach(opts, i, max, k, v) {
      const char *name = yyjson_get_str(k);
      const registry_entry_t *e = exposed(p, name);
      if (strlen(name) != yyjson_get_len(k) || !e)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported option: %s", name);
      char buf[MCP_SERVER_REQUEST_BUF_BUFFER_SIZE];
      bool omitted = false;
      err = options_json_parse_value(name, v, buf, sizeof(buf), &omitted);
      if (err)
        return err;
      if (omitted)
        continue;
      double n = yyjson_get_num(v);
      if ((!strcmp(name, "width") && (n < e->metadata.numeric_range.min || n > 512)) ||
          (!strcmp(name, "height") && (n < e->metadata.numeric_range.min || n > 256)) ||
          (!strcmp(name, "snapshot-delay") && (n < 0 || n > 30)) || (!strcmp(name, "fps") && (n < 0 || n > 144)))
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option %s is out of bounds", name);
      err = option(r, name, buf);
      if (err)
        return err;
      if (!strcmp(name, "width"))
        r->options.width = (int)n;
      else if (!strcmp(name, "height"))
        r->options.height = (int)n;
      else if (!strcmp(name, "color-mode")) {
        if (!strcmp(buf, "16"))
          r->options.color_mode = TERM_COLOR_16;
        else if (!strcmp(buf, "256"))
          r->options.color_mode = TERM_COLOR_256;
        else if (!strcmp(buf, "truecolor") || !strcmp(buf, "24bit"))
          r->options.color_mode = TERM_COLOR_TRUECOLOR;
        else
          r->options.color_mode = TERM_COLOR_NONE;
      } else if (!strcmp(name, "palette"))
        SAFE_STRNCPY(r->options.palette, buf, sizeof(r->options.palette));
      else if (!strcmp(name, "palette-chars"))
        SAFE_STRNCPY(r->options.palette_chars, buf, sizeof(r->options.palette_chars));
    }
  bool synthetic = enabled(opts, "test-pattern"), test_audio = enabled(opts, "test-audio");
  yyjson_val *audio_device = mcp_get(a, "audio_device"), *volume = mcp_get(a, "volume");
  if (audio_device) {
    if (!yyjson_is_int(audio_device) || yyjson_get_sint(audio_device) < -1 || yyjson_get_sint(audio_device) > INT_MAX)
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio_device must be -1 or a nonnegative device index");
    char index[MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE];
    SAFE_SNPRINTF(index, sizeof(index), "%d", (int)yyjson_get_sint(audio_device));
    err = option(r, "microphone-index", index);
    if (err)
      return err;
  }
  if (volume) {
    if (!yyjson_is_num(volume) || yyjson_get_num(volume) < 0 || yyjson_get_num(volume) > 1)
      return SET_ERRNO(ERROR_INVALID_PARAM, "volume must be a number from 0 to 1");
    char value[MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE];
    bool omitted = false;
    err = options_json_parse_value("microphone-volume", volume, value, sizeof(value), &omitted);
    if (err)
      return err;
    if (mcp_get(opts, "microphone-volume") || mcp_get(opts, "ivolume"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "volume conflicts with options.microphone-volume/ivolume");
    err = option(r, "microphone-volume", value);
    if (err)
      return err;
  }
  if (tool == MCP_FILE) {
    if (synthetic || test_audio) {
      if (mcp_get(a, "path") || mcp_get(a, "data_base64"))
        return SET_ERRNO(ERROR_INVALID_PARAM, "Synthetic source conflicts with media");
      if (!synthetic) {
        option(r, "waveform", "true");
        option(r, "audio", "true");
      }
    } else {
      err = source_file(p, a, r);
      if (err)
        return err;
    }
  } else if (tool == MCP_URL) {
    if (synthetic)
      return SET_ERRNO(ERROR_INVALID_PARAM, "test-pattern conflicts with URL");
    err = source_url(p, mcp_get(a, "url"), r);
    if (err)
      return err;
  } else if (tool == MCP_WEBCAM) {
    r->capture_webcam = !synthetic;
    bool record_audio =
        audio_device || volume || enabled(opts, "audio") ||
        (mcp_get(a, "output_path") && yyjson_get_num(mcp_get(opts, "snapshot-delay")) > 0 && !mcp_get(opts, "audio"));
    if (record_audio && mcp_get(opts, "audio") && !enabled(opts, "audio"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Microphone selection conflicts with options.audio=false");
    if (record_audio && !test_audio) {
      option(r, "audio", "true");
      option(r, "audio-source", "mic");
      option(r, "audio-capture-source", "mic");
    }
    yyjson_val *dev = mcp_get(a, "video_device");
    if (dev) {
      if (!yyjson_is_int(dev) || yyjson_get_sint(dev) < 0 || yyjson_get_sint(dev) > 10)
        return SET_ERRNO(ERROR_INVALID_PARAM, "video_device must be 0–10");
      char b[MCP_SERVER_REQUEST_B_BUFFER_SIZE];
      SAFE_SNPRINTF(b, sizeof(b), "%d", (int)yyjson_get_sint(dev));
      option(r, "webcam-index", b);
    }
  } else {
    if (synthetic)
      return SET_ERRNO(ERROR_INVALID_PARAM, "test-pattern conflicts with audio visualization");
    yyjson_val *visual = mcp_get(a, "visualization");
    if (!yyjson_is_str(visual) || (strcmp(yyjson_get_str(visual), "waveform") && strcmp(yyjson_get_str(visual), "fft")))
      return SET_ERRNO(ERROR_INVALID_PARAM, "visualization must be waveform or fft");
    option(r, yyjson_get_str(visual), "true");
    option(r, "audio", "true");
    yyjson_val *audio = mcp_get(a, "audio");
    static const char *const audio_fields[] = {"type", "path", "data_base64", "mime_type", "url", NULL};
    if (audio) {
      err = check_fields(audio, audio_fields);
      if (err)
        return err;
    }
    yyjson_val *type = mcp_get(audio, "type");
    if (type && !yyjson_is_str(type))
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio.type must be a string");
    const char *t = type ? yyjson_get_str(type) : (audio_device || volume ? "microphone" : "test");
    if ((audio_device || volume) && strcmp(t, "microphone"))
      return SET_ERRNO(ERROR_INVALID_PARAM, "audio_device and volume require microphone audio");
    if (!strcmp(t, "test")) {
      if (audio && yyjson_obj_size(audio) > 1)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Test audio has no source fields");
      option(r, "test-audio", "true");
      option(r, "audio-source", "all");
    } else if (!strcmp(t, "file")) {
      if (mcp_get(audio, "url") || mcp_get(a, "audio_device") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      err = source_file(p, audio, r);
      if (err)
        return err;
      option(r, "audio-source", "media");
      option(r, "audio-capture-source", "media");
    } else if (!strcmp(t, "url")) {
      if (mcp_get(audio, "path") || mcp_get(audio, "data_base64") || mcp_get(a, "audio_device") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      err = source_url(p, mcp_get(audio, "url"), r);
      if (err)
        return err;
      option(r, "audio-source", "media");
      option(r, "audio-capture-source", "media");
    } else if (!strcmp(t, "microphone") && !p->restricted) {
      if (mcp_get(audio, "path") || mcp_get(audio, "data_base64") || mcp_get(audio, "url") || test_audio)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Conflicting audio sources");
      option(r, "audio-source", "mic");
      option(r, "audio-capture-source", "mic");
    } else
      return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported audio source");
  }
  if (test_audio)
    option(r, "audio", "true");
  if (tool != MCP_WEBCAM && tool != MCP_VISUALIZATION && !test_audio)
    option(r, "audio-capture-source", "media");
  yyjson_val *format = mcp_get(a, "output_format");
  if (format && (!p->restricted || !p->hosted))
    return SET_ERRNO(ERROR_INVALID_PARAM, "output_format is available only in HTTP server mode");
  if (p->restricted && p->hosted) {
    const char *ext =
        format && yyjson_is_str(format) ? yyjson_get_str(format)
        : (yyjson_is_false(mcp_get(opts, "snapshot")) || yyjson_get_num(mcp_get(opts, "snapshot-delay")) > 0) ? "mp4"
                                                                                                              : "png";
    if ((format && !yyjson_is_str(format)) || !mcp_output_mime(ext) || !output_format_available(ext))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported output_format");
    unsigned char random[16];
    char token[33], path[PLATFORM_MAX_PATH_LENGTH];
    randombytes_buf(random, sizeof(random));
    sodium_bin2hex(token, sizeof(token), random, sizeof(random));
    int path_len =
        safe_snprintf(path, sizeof(path), "%s/%lld-%s.%s", p->downloads_dir, (long long)time(NULL) + 1800, token, ext);
    if (path_len < 0 || (size_t)path_len >= sizeof(path))
      return SET_ERRNO(ERROR_INVALID_PARAM, "Download path is too long");
    err = stage_output(path, r);
    if (err)
      return err;
  }
  yyjson_val *output = mcp_get(a, "output_path");
  if (output) {
    if (!yyjson_is_str(output))
      return SET_ERRNO(ERROR_INVALID_PARAM, "output_path must be a string");
    err = stage_output(yyjson_get_str(output), r);
    if (err)
      return err;
  }
  if (output_mode && !strcmp(yyjson_get_str(output_mode), "files") && !r->output_path[0])
    return SET_ERRNO(ERROR_INVALID_PARAM, "output=files requires output_path");
  return ASCIICHAT_OK;
}

References http_renderer_process_request_t::argv, ASCIICHAT_OK, http_renderer_process_request_t::capture_webcam, http_render_options_t::color_mode, mcp_policy_t::downloads_dir, enabled, ERROR_FILE_OPERATION, ERROR_INVALID_PARAM, http_render_options_t::height, mcp_policy_t::hosted, HTTP_RENDER_OUTPUT_FILE, HTTP_RENDER_OUTPUT_TEXT, index, MCP_FILE, mcp_output_mime(), MCP_REQUEST_ARGV_CAPACITY, MCP_SERVER_REQUEST_B_BUFFER_SIZE, MCP_SERVER_REQUEST_BUF_BUFFER_SIZE, MCP_SERVER_REQUEST_INDEX_BUFFER_SIZE, MCP_SERVER_REQUEST_VALUE_BUFFER_SIZE, MCP_URL, MCP_VISUALIZATION, MCP_WEBCAM, http_renderer_process_request_t::options, options_json_parse_value(), http_renderer_process_request_t::output_path, http_renderer_process_request_t::output_type, http_render_options_t::palette, http_render_options_t::palette_chars, PLATFORM_MAX_PATH_LENGTH, mcp_policy_t::restricted, SAFE_CALLOC, SAFE_SNPRINTF, safe_snprintf(), SAFE_STRNCPY, SET_ERRNO, http_renderer_process_request_t::timeout_ms, and http_render_options_t::width.

Referenced by mcp_dispatch().

mcp_server_main()

int mcp_server_main

(

void

)

Definition at line 21 of file mcp-server/main.c.

                          {
  if (strcmp(GET_OPTION(mcp_transport), "http") && strcmp(GET_OPTION(mcp_transport), "stdio"))
    return SET_ERRNO(ERROR_CONFIG, "--transport must be http or stdio");
  mcp_server_t *s = SAFE_CALLOC(1, sizeof(*s), mcp_server_t *);
  s->policy = (mcp_policy_t){.hosted = !strcmp(GET_OPTION(mcp_transport), "http"),
                             .restricted = GET_OPTION(mcp_server_restricted),
                             .address = GET_OPTION(address),
                             .address6 = GET_OPTION(address6),
                             .port = GET_OPTION(port),
                             .origin = GET_OPTION(http_origin),
                             .tls_cert = GET_OPTION(tls_cert),
                             .tls_key = GET_OPTION(tls_key),
                             .tls_password = GET_OPTION(tls_key_password),
                             .max_jobs = (unsigned)GET_OPTION(max_clients),
                             .downloads_url_prefix = GET_OPTION(mcp_downloads_url_prefix)};
  if (s->policy.restricted && s->policy.hosted && s->policy.downloads_url_prefix && *s->policy.downloads_url_prefix) {
    const char *prefix = s->policy.downloads_url_prefix;
    const char *authority = !strncmp(prefix, "https://", sizeof("https://") - 1) ? prefix + 8
                            : !strncmp(prefix, "http://", sizeof("http://") - 1) ? prefix + 7
                                                                                 : NULL;
    if (!authority || !*authority || *authority == '/' || strpbrk(prefix, " \t\r\n?#")) {
      SAFE_FREE(s);
      return SET_ERRNO(ERROR_CONFIG, "--downloads-url-prefix must be an HTTP(S) URL without query or fragment");
    }
  }
  if (s->policy.restricted && s->policy.hosted) {
    const char *override = GET_OPTION(mcp_downloads_dir);
    char *data_dir = NULL;
    if (override && *override) {
      SAFE_STRNCPY(s->policy.downloads_dir, override, sizeof(s->policy.downloads_dir));
    } else {
      data_dir = platform_get_data_dir();
      if (!data_dir) {
        SAFE_FREE(s);
        return SET_ERRNO(ERROR_CONFIG, "Cannot determine MCP data directory");
      }
      SAFE_SNPRINTF(s->policy.downloads_dir, sizeof(s->policy.downloads_dir), "%s/downloads", data_dir);
      SAFE_FREE(data_dir);
    }
    asciichat_error_t directory_error = platform_mkdir_recursive(s->policy.downloads_dir, 0700);
    if (directory_error != ASCIICHAT_OK) {
      SAFE_FREE(s);
      return directory_error;
    }
    uv_fs_t resolved;
    int rc = uv_fs_realpath(NULL, &resolved, s->policy.downloads_dir, NULL);
    if (rc < 0 || strlen((const char *)resolved.ptr) >= sizeof(s->policy.downloads_dir)) {
      uv_fs_req_cleanup(&resolved);
      SAFE_FREE(s);
      return SET_ERRNO(ERROR_CONFIG, "Cannot resolve MCP downloads directory");
    }
    SAFE_STRNCPY(s->policy.downloads_dir, (const char *)resolved.ptr, sizeof(s->policy.downloads_dir));
    uv_fs_req_cleanup(&resolved);
  }
  log_set_terminal_output(s->policy.hosted);
  unsigned available_cpus = uv_available_parallelism();
  if (!available_cpus)
    available_cpus = 1;
  if (!s->policy.max_jobs || s->policy.max_jobs > available_cpus)
    s->policy.max_jobs = available_cpus;
  if (s->policy.hosted && (!!s->policy.tls_cert[0] != !!s->policy.tls_key[0])) {
    asciichat_error_t err = SET_ERRNO(ERROR_CONFIG, "MCP HTTPS requires both --tls-cert and --tls-key");
    log_error("MCP HTTPS requires both --tls-cert and --tls-key");
    SAFE_FREE(s);
    return err;
  }
  // Initialize immutable registry metadata before worker threads are started.
  registry_init_size();
  if (sodium_init() < 0 || mutex_init(&s->output_mutex, "mcp.output")) {
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_INVALID_STATE, "Cannot initialize MCP server");
  }
  s->jobs = SAFE_CALLOC(s->policy.max_jobs, sizeof(*s->jobs), mcp_job_t *);
  if (!s->jobs) {
    mutex_destroy(&s->output_mutex);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate MCP render jobs");
  }
  log_info("MCP server started (%s, %s capabilities, %u render jobs)", s->policy.hosted ? "HTTP" : "stdio",
           s->policy.restricted ? "restricted" : "local", s->policy.max_jobs);
  if (s->policy.hosted) {
    platform_systemd_notify_status("MCP HTTP listener started");
    platform_systemd_notify_ready();
  }
  stats_runtime_set_provider(mcp_stats_view, s);
  asciichat_error_t err = s->policy.hosted ? mcp_http_run(s) : mcp_stdio_run(s);
  stats_runtime_set_provider(NULL, NULL);
  for (unsigned i = 0; i < s->policy.max_jobs; ++i)
    if (s->jobs[i].renderer_job.started)
      http_renderer_job_cancel(&s->jobs[i].renderer_job);
  mcp_jobs_reap(s, true);
  mcp_stdio_release();
  mutex_destroy(&s->output_mutex);
  SAFE_FREE(s->jobs);
  SAFE_FREE(s);
  return err;
}

References ASCIICHAT_OK, mcp_policy_t::downloads_dir, mcp_policy_t::downloads_url_prefix, ERROR_CONFIG, ERROR_INVALID_STATE, ERROR_MEMORY, GET_OPTION, mcp_policy_t::hosted, http_renderer_job_cancel(), mcp_server::jobs, log_error, log_info, log_set_terminal_output(), mcp_policy_t::max_jobs, mcp_http_run(), mcp_jobs_reap(), mcp_stdio_release(), mcp_stdio_run(), mcp_server::output_mutex, mcp_server::policy, registry_init_size(), mcp_job::renderer_job, mcp_policy_t::restricted, SAFE_CALLOC, SAFE_FREE, SAFE_SNPRINTF, SAFE_STRNCPY, SET_ERRNO, http_renderer_job::started, stats_runtime_set_provider(), mcp_policy_t::tls_cert, and mcp_policy_t::tls_key.

mcp_stdio_release()

void mcp_stdio_release

(

void

)

Definition at line 13 of file stdio.c.

                             {
  if (protocol_fd >= 0) {
    platform_close(protocol_fd);
    protocol_fd = -1;
  }
}

Referenced by mcp_server_main().

mcp_stdio_reserve()

asciichat_error_t mcp_stdio_reserve

(

void

)

Definition at line 7 of file stdio.c.

                                          {
  protocol_fd = platform_dup(STDOUT_FILENO);
  if (protocol_fd < 0)
    return SET_ERRNO(ERROR_FILE_OPERATION, "Cannot reserve MCP stdout");
  return platform_dup2(STDERR_FILENO, STDOUT_FILENO);
}

References ERROR_FILE_OPERATION, platform_dup(), platform_dup2(), and SET_ERRNO.

Referenced by main().

mcp_stdio_run()

asciichat_error_t mcp_stdio_run

(

mcp_server_t *

server

)

Definition at line 31 of file stdio.c.

                                                 {
  char *line = SAFE_MALLOC(MCP_MAX_INPUT + 1, char *);
  size_t n = 0;
  bool overflow = false;
  while (!atomic_load_bool(&s->stopping)) {
    int c = fgetc(stdin);
    if (c == EOF)
      break;
    if (c != '\n') {
      if (n < MCP_MAX_INPUT)
        line[n++] = (char)c;
      else
        overflow = true;
      continue;
    }
    if (n && line[n - 1] == '\r')
      --n;
    if (!n && !overflow)
      continue;
    yyjson_doc *doc = overflow ? NULL : yyjson_read(line, n, YYJSON_READ_NOFLAG);
    bool pending = false;
    yyjson_mut_doc *response =
        doc ? mcp_dispatch(s, doc, NULL, NULL, &pending)
            : mcp_error(NULL, overflow ? -32600 : -32700, overflow ? "Request exceeds 24 MiB" : "Parse error");
    if (response) {
      mcp_stdio_send(s, response);
      yyjson_mut_doc_free(response);
    }
    if (doc)
      yyjson_doc_free(doc);
    n = 0;
    overflow = false;
    mcp_jobs_reap(s, false);
  }
  SAFE_FREE(line);
  for (unsigned i = 0; i < s->policy.max_jobs; ++i)
    if (s->jobs[i].renderer_job.started)
      http_renderer_job_cancel(&s->jobs[i].renderer_job);
  mcp_jobs_reap(s, true);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_renderer_job_cancel(), mcp_server::jobs, mcp_policy_t::max_jobs, mcp_dispatch(), mcp_error(), mcp_jobs_reap(), MCP_MAX_INPUT, mcp_stdio_send(), mcp_server::policy, mcp_job::renderer_job, SAFE_FREE, SAFE_MALLOC, http_renderer_job::started, and mcp_server::stopping.

Referenced by mcp_server_main().

mcp_stdio_send()

void mcp_stdio_send	(	mcp_server_t *	server,
		yyjson_mut_doc *	response )

Definition at line 19 of file stdio.c.

                                                               {
  size_t size;
  char *json = yyjson_mut_write(response, 0, &size);
  if (!json)
    return;
  mutex_lock(&s->output_mutex);
  bool ok = platform_write_all(protocol_fd, json, size) == size && platform_write_all(protocol_fd, "\n", 1) == 1;
  mutex_unlock(&s->output_mutex);
  free(json); // yyjson owns allocations made by its default allocator.
  if (!ok)
    atomic_store_bool(&s->stopping, true);
}

References mcp_server::output_mutex, platform_write_all(), and mcp_server::stopping.

Referenced by mcp_stdio_run().

mcp_tools_schema()

yyjson_mut_val * mcp_tools_schema	(	yyjson_mut_doc *	doc,
		const mcp_policy_t *	policy )

Definition at line 158 of file request.c.

                                                                           {
  const char *names[] = {"render_file", "render_url", "render_webcam", "render_visualization"};
  const char *descs[] = {
      "Convert uploaded media or a local file into ASCII art. Source can be omitted for test-pattern/test-audio.",
      "Convert URL media into ASCII art using the CLI media resolver.",
      "Capture a local webcam as ASCII art; test-pattern avoids camera access.",
      "Render waveform or FFT from test audio, uploaded audio, URL audio, or local audio/microphone."};
  yyjson_mut_val *tools = yyjson_mut_arr(d);
  for (int i = 0; i < 4; ++i) {
    if (p->restricted && i == MCP_WEBCAM)
      continue;
    yyjson_mut_val *tool = yyjson_mut_obj(d), *s = object_schema(d), *props = yyjson_mut_obj_get(s, "properties");
    yyjson_mut_obj_add_str(d, tool, "name", names[i]);
    yyjson_mut_obj_add_str(d, tool, "description", descs[i]);
    yyjson_mut_obj_add_val(d, props, "options", options_schema(d, p));
    property(d, s, "timeout_ms", "integer", "Maximum job time, 1000–60000 ms; default 45000.");
    if (p->restricted && p->hosted) {
      property(d, s, "output_format", "string",
               "Output format: png, jpg, jpeg, bmp, webp, gif, mp4, mov, mkv, webm, avi, flv, ogv, ogg or 3gp. "
               "Defaults to png for a single frame or mp4 for a timed or continuous render. GIF renders media to EOF "
               "unless snapshot or snapshot-delay is specified.");
      yyjson_mut_val *available = yyjson_mut_arr(d);
      for (size_t i = 0; mcp_output_formats[i]; ++i)
        if (output_format_available(mcp_output_formats[i]))
          yyjson_mut_arr_add_str(d, available, mcp_output_formats[i]);
      yyjson_mut_obj_add_val(d, yyjson_mut_obj_get(props, "output_format"), "enum", available);
    }
    if (!p->restricted)
      property(d, s, "output_path", "string",
               "Save rendered ASCII art as an image/video, selected by extension. Existing files are never replaced.");
    property(d, s, "output", "string", "Output mode: text or files. Defaults to text unless output_path is supplied.");
    const char *output_modes[] = {"text", "files", NULL};
    enum_strings(d, yyjson_mut_obj_get(props, "output"), output_modes);
    if (i == MCP_FILE)
      file_properties(d, s, !p->restricted);
    if (i == MCP_URL) {
      property(d, s, "url", "string", "HTTP/HTTPS media URL (local profile also accepts RTSP/RTMP).");
      yyjson_mut_val *required = yyjson_mut_arr(d);
      yyjson_mut_arr_add_str(d, required, "url");
      yyjson_mut_obj_add_val(d, s, "required", required);
    }
    if (i == MCP_WEBCAM) {
      property(d, s, "video_device", "integer", "Local webcam index, 0–10; default 0.");
      yyjson_mut_val *device = yyjson_mut_obj_get(props, "video_device");
      yyjson_mut_obj_add_int(d, device, "default", 0);
      yyjson_mut_obj_add_int(d, device, "minimum", 0);
      yyjson_mut_obj_add_int(d, device, "maximum", 10);
    }
    if (!p->restricted && (i == MCP_WEBCAM || i == MCP_VISUALIZATION)) {
      property(d, s, "audio_device", "integer", "Microphone index; -1 or omitted selects the system default.");
      yyjson_mut_val *device = yyjson_mut_obj_get(props, "audio_device");
      yyjson_mut_obj_add_int(d, device, "default", -1);
      yyjson_mut_obj_add_int(d, device, "minimum", -1);
      yyjson_mut_obj_add_int(d, device, "maximum", INT_MAX);
      yyjson_mut_val *volume = options_json_schema_for_option(d, "microphone-volume");
      yyjson_mut_obj_remove_str(volume, "description");
      yyjson_mut_obj_add_str(d, volume, "description", "Microphone volume multiplier, 0–1; 0 mutes, 1 is normal.");
      yyjson_mut_obj_add_real(d, volume, "default", 1);
      yyjson_mut_obj_add_real(d, volume, "minimum", 0);
      yyjson_mut_obj_add_real(d, volume, "maximum", 1);
      yyjson_mut_obj_add_val(d, props, "volume", volume);
    }
    if (i == MCP_VISUALIZATION) {
      property(d, s, "visualization", "string", "waveform or fft");
      const char *values[] = {"waveform", "fft", NULL};
      enum_strings(d, yyjson_mut_obj_get(props, "visualization"), values);
      yyjson_mut_val *audio = object_schema(d);
      property(d, audio, "type", "string", "Audio source, default test.");
      const char *types[] = {"test", "file", "url", "microphone", NULL};
      const char *remote_types[] = {"test", "file", "url", NULL};
      enum_strings(d, yyjson_mut_obj_get(yyjson_mut_obj_get(audio, "properties"), "type"),
                   p->restricted ? remote_types : types);
      file_properties(d, audio, !p->restricted);
      property(d, audio, "url", "string", "Audio URL.");
      yyjson_mut_obj_add_val(d, props, "audio", audio);
      yyjson_mut_val *req = yyjson_mut_arr(d);
      yyjson_mut_arr_add_str(d, req, "visualization");
      yyjson_mut_obj_add_val(d, s, "required", req);
    }
    yyjson_mut_val *out = object_schema(d);
    property(d, out, "ascii", "string", "Rendered text; saved media may have no terminal text.");
    property(d, out, "elapsed_ms", "integer", "Worker wall-clock duration.");
    if (p->restricted && p->hosted) {
      property(d, out, "download_url", "string", "Temporary URL for the rendered file.");
      property(d, out, "expires_at", "string", "UTC expiration timestamp in RFC 3339 format.");
    }
    yyjson_mut_val *saved = yyjson_mut_obj(d), *items = yyjson_mut_obj(d);
    yyjson_mut_obj_add_str(d, saved, "type", "array");
    yyjson_mut_obj_add_str(d, items, "type", "string");
    yyjson_mut_obj_add_val(d, saved, "items", items);
    yyjson_mut_obj_add_val(d, yyjson_mut_obj_get(out, "properties"), "saved_files", saved);
    yyjson_mut_val *required = yyjson_mut_arr(d);
    yyjson_mut_arr_add_str(d, required, "ascii");
    yyjson_mut_arr_add_str(d, required, "elapsed_ms");
    yyjson_mut_arr_add_str(d, required, "saved_files");
    yyjson_mut_obj_add_val(d, out, "required", required);
    yyjson_mut_obj_add_val(d, tool, "outputSchema", out);
    yyjson_mut_obj_add_val(d, tool, "inputSchema", s);
    yyjson_mut_arr_add_val(tools, tool);
  }
  if (!p->restricted) {
    yyjson_mut_val *tool = yyjson_mut_obj(d);
    yyjson_mut_obj_add_str(d, tool, "name", "device_list");
    yyjson_mut_obj_add_str(d, tool, "description",
                           "List local video and microphone device indices, names, and defaults.");
    yyjson_mut_obj_add_val(d, tool, "inputSchema", object_schema(d));
    yyjson_mut_val *annotations = yyjson_mut_obj(d);
    yyjson_mut_obj_add_bool(d, annotations, "readOnlyHint", true);
    yyjson_mut_obj_add_val(d, tool, "annotations", annotations);
    yyjson_mut_arr_add_val(tools, tool);
  }
  return tools;
}

References mcp_policy_t::hosted, MCP_FILE, mcp_output_formats, MCP_URL, MCP_VISUALIZATION, MCP_WEBCAM, options_json_schema_for_option(), out, and mcp_policy_t::restricted.

Referenced by mcp_dispatch().

Variable Documentation

mcp_output_formats

const char* const mcp_output_formats[]

extern

Definition at line 7 of file downloads.c.

                                         {"png", "jpg",  "jpeg", "bmp", "webp", "gif", "mp4", "mov",
                                          "mkv", "webm", "avi",  "flv", "ogv",  "ogg", "3gp", NULL};

Referenced by mcp_output_mime(), and mcp_tools_schema().