@tencent-ai/agent-sdk 0.3.206 → 0.3.210

package/cli/vendor/shim/native/binding.gyp

@@ -0,0 +1,13 @@
+{
+  "targets": [
+    {
+      "target_name": "brokered_sandbox_native",
+      "sources": [ "brokered_sandbox_native.c" ],
+      "conditions": [
+        [ "OS=='mac'", {
+          "defines": [ "BROKERED_SANDBOX_DARWIN=1" ]
+        } ]
+      ]
+    }
+  ]
+}

package/cli/vendor/shim/native/brokered_sandbox_native.c

@@ -0,0 +1,293 @@
+#include <node_api.h>
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__APPLE__)
+#include <dlfcn.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/un.h>
+#include <unistd.h>
+#endif
+
+#define BROKER_RESPONSE_MAX_BYTES (1024 * 1024)
+
+static napi_value throw_error(napi_env env, const char *message) {
+    napi_throw_error(env, NULL, message);
+    return NULL;
+}
+
+static char *read_string_arg(napi_env env, napi_value value, const char *name) {
+    size_t length = 0;
+    napi_status status = napi_get_value_string_utf8(env, value, NULL, 0, &length);
+    if (status != napi_ok) {
+        char message[128];
+        snprintf(message, sizeof(message), "%s must be a string", name);
+        napi_throw_type_error(env, NULL, message);
+        return NULL;
+    }
+
+    char *buffer = (char *)malloc(length + 1);
+    if (!buffer) {
+        napi_throw_error(env, NULL, "Out of memory");
+        return NULL;
+    }
+    status = napi_get_value_string_utf8(env, value, buffer, length + 1, &length);
+    if (status != napi_ok) {
+        free(buffer);
+        char message[128];
+        snprintf(message, sizeof(message), "Failed to read %s", name);
+        napi_throw_error(env, NULL, message);
+        return NULL;
+    }
+    return buffer;
+}
+
+static uint32_t read_timeout_arg(napi_env env, napi_value value) {
+    uint32_t timeout_ms = 5000;
+    if (value) {
+        napi_get_value_uint32(env, value, &timeout_ms);
+    }
+    if (timeout_ms == 0) {
+        timeout_ms = 5000;
+    }
+    return timeout_ms;
+}
+
+#if defined(__APPLE__)
+typedef int64_t (*sandbox_extension_consume_fn)(const char *);
+
+static sandbox_extension_consume_fn get_sandbox_extension_consume(void) {
+    static sandbox_extension_consume_fn fn = NULL;
+    static int loaded = 0;
+    if (loaded) {
+        return fn;
+    }
+    loaded = 1;
+
+    fn = (sandbox_extension_consume_fn)dlsym(RTLD_DEFAULT, "sandbox_extension_consume");
+    if (fn) {
+        return fn;
+    }
+
+    void *handle = dlopen("/usr/lib/libsandbox.dylib", RTLD_LAZY);
+    if (!handle) {
+        return NULL;
+    }
+    fn = (sandbox_extension_consume_fn)dlsym(handle, "sandbox_extension_consume");
+    return fn;
+}
+
+static int set_socket_timeout(int fd, uint32_t timeout_ms) {
+    struct timeval tv;
+    tv.tv_sec = timeout_ms / 1000;
+    tv.tv_usec = (timeout_ms % 1000) * 1000;
+    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) != 0) {
+        return -1;
+    }
+    if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) != 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static int write_all(int fd, const char *buffer, size_t length) {
+    size_t offset = 0;
+    while (offset < length) {
+        ssize_t written = write(fd, buffer + offset, length - offset);
+        if (written < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return -1;
+        }
+        if (written == 0) {
+            errno = EPIPE;
+            return -1;
+        }
+        offset += (size_t)written;
+    }
+    return 0;
+}
+
+static char *request_broker_sync(const char *socket_path, const char *line, uint32_t timeout_ms, char *error, size_t error_size) {
+    int fd = -1;
+    char *response = NULL;
+    size_t length = 0;
+    size_t capacity = 4096;
+
+    fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd < 0) {
+        snprintf(error, error_size, "socket failed: %s", strerror(errno));
+        return NULL;
+    }
+    if (set_socket_timeout(fd, timeout_ms) != 0) {
+        snprintf(error, error_size, "setsockopt timeout failed: %s", strerror(errno));
+        close(fd);
+        return NULL;
+    }
+
+    struct sockaddr_un addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    if (strlen(socket_path) >= sizeof(addr.sun_path)) {
+        snprintf(error, error_size, "broker socket path is too long");
+        close(fd);
+        return NULL;
+    }
+    strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
+
+    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
+        snprintf(error, error_size, "connect failed: %s", strerror(errno));
+        close(fd);
+        return NULL;
+    }
+
+    if (write_all(fd, line, strlen(line)) != 0 || write_all(fd, "\n", 1) != 0) {
+        snprintf(error, error_size, "write failed: %s", strerror(errno));
+        close(fd);
+        return NULL;
+    }
+
+    response = (char *)malloc(capacity);
+    if (!response) {
+        snprintf(error, error_size, "out of memory");
+        close(fd);
+        return NULL;
+    }
+
+    while (length + 1 < BROKER_RESPONSE_MAX_BYTES) {
+        char chunk[1024];
+        ssize_t count = read(fd, chunk, sizeof(chunk));
+        if (count < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            snprintf(error, error_size, "read failed: %s", strerror(errno));
+            free(response);
+            close(fd);
+            return NULL;
+        }
+        if (count == 0) {
+            snprintf(error, error_size, "broker closed without a response");
+            free(response);
+            close(fd);
+            return NULL;
+        }
+
+        for (ssize_t i = 0; i < count; i++) {
+            if (chunk[i] == '\n') {
+                response[length] = '\0';
+                close(fd);
+                return response;
+            }
+            if (length + 1 >= capacity) {
+                size_t next_capacity = capacity * 2;
+                if (next_capacity > BROKER_RESPONSE_MAX_BYTES) {
+                    next_capacity = BROKER_RESPONSE_MAX_BYTES;
+                }
+                char *next = (char *)realloc(response, next_capacity);
+                if (!next) {
+                    snprintf(error, error_size, "out of memory");
+                    free(response);
+                    close(fd);
+                    return NULL;
+                }
+                response = next;
+                capacity = next_capacity;
+            }
+            response[length++] = chunk[i];
+        }
+    }
+
+    snprintf(error, error_size, "broker response exceeds limit");
+    free(response);
+    close(fd);
+    return NULL;
+}
+#endif
+
+static napi_value ConsumeSandboxExtension(napi_env env, napi_callback_info info) {
+#if defined(__APPLE__)
+    size_t argc = 1;
+    napi_value argv[1];
+    napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+    if (argc < 1) {
+        return throw_error(env, "consumeSandboxExtension requires a token");
+    }
+
+    char *token = read_string_arg(env, argv[0], "token");
+    if (!token) {
+        return NULL;
+    }
+
+    sandbox_extension_consume_fn consume = get_sandbox_extension_consume();
+    if (!consume) {
+        free(token);
+        return throw_error(env, "sandbox_extension_consume is unavailable");
+    }
+
+    int64_t handle = consume(token);
+    free(token);
+    napi_value result;
+    napi_create_int64(env, handle, &result);
+    return result;
+#else
+    (void)info;
+    return throw_error(env, "sandbox_extension_consume is only available on macOS");
+#endif
+}
+
+static napi_value RequestBrokerSync(napi_env env, napi_callback_info info) {
+#if defined(__APPLE__)
+    size_t argc = 3;
+    napi_value argv[3];
+    napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+    if (argc < 2) {
+        return throw_error(env, "requestBrokerSync requires socketPath and line");
+    }
+
+    char *socket_path = read_string_arg(env, argv[0], "socketPath");
+    if (!socket_path) {
+        return NULL;
+    }
+    char *line = read_string_arg(env, argv[1], "line");
+    if (!line) {
+        free(socket_path);
+        return NULL;
+    }
+    uint32_t timeout_ms = argc >= 3 ? read_timeout_arg(env, argv[2]) : 5000;
+
+    char error[512];
+    error[0] = '\0';
+    char *response = request_broker_sync(socket_path, line, timeout_ms, error, sizeof(error));
+    free(socket_path);
+    free(line);
+    if (!response) {
+        return throw_error(env, error[0] ? error : "broker request failed");
+    }
+
+    napi_value result;
+    napi_create_string_utf8(env, response, NAPI_AUTO_LENGTH, &result);
+    free(response);
+    return result;
+#else
+    (void)info;
+    return throw_error(env, "broker sync IPC is only available on macOS");
+#endif
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
+    napi_property_descriptor descriptors[] = {
+        { "consumeSandboxExtension", NULL, ConsumeSandboxExtension, NULL, NULL, NULL, napi_default, NULL },
+        { "requestBrokerSync", NULL, RequestBrokerSync, NULL, NULL, NULL, napi_default, NULL },
+    };
+    napi_define_properties(env, exports, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);
+    return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)