@north-light/crouter 0.3.349 → 0.3.351

package/src/native/linux/addon.c

@@ -0,0 +1,249 @@
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/openat2.h>
+#include <math.h>
+#include <node_api.h>
+#include <poll.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <uv.h>
+
+#define CHECK(call) do { if ((call) != napi_ok) { napi_throw_error(env, NULL, "N-API operation failed"); return NULL; } } while (0)
+
+static napi_value system_error(napi_env env, const char *operation) {
+  int saved = errno;
+  napi_throw_error(env, uv_err_name(-saved), operation);
+  return NULL;
+}
+
+static int argument_count(napi_env env, size_t actual, size_t expected) {
+  if (actual == expected) return 1;
+  napi_throw_type_error(env, NULL, "wrong number of arguments");
+  return 0;
+}
+
+static int unsigned_arg(napi_env env, napi_value value, uint32_t *out) {
+  napi_valuetype type;
+  double number;
+  if (napi_typeof(env, value, &type) != napi_ok || type != napi_number ||
+      napi_get_value_double(env, value, &number) != napi_ok ||
+      !isfinite(number) || number < 0 || number > UINT32_MAX || floor(number) != number) {
+    napi_throw_type_error(env, NULL, "expected an unsigned 32-bit integer");
+    return 0;
+  }
+  *out = (uint32_t)number;
+  return 1;
+}
+
+static int fd_arg(napi_env env, napi_value value, int *out) {
+  uint32_t number;
+  if (!unsigned_arg(env, value, &number)) return 0;
+  if (number > INT32_MAX) {
+    napi_throw_range_error(env, NULL, "file descriptor is too large");
+    return 0;
+  }
+  *out = (int)number;
+  return 1;
+}
+
+static int string_arg(napi_env env, napi_value value, char **out) {
+  napi_valuetype type;
+  size_t length;
+  if (napi_typeof(env, value, &type) != napi_ok || type != napi_string ||
+      napi_get_value_string_utf8(env, value, NULL, 0, &length) != napi_ok) {
+    napi_throw_type_error(env, NULL, "expected a path string");
+    return 0;
+  }
+  char *path = malloc(length + 1);
+  if (path == NULL) { napi_throw_error(env, "ENOMEM", "allocating path"); return 0; }
+  size_t written;
+  if (napi_get_value_string_utf8(env, value, path, length + 1, &written) != napi_ok ||
+      written != length || memchr(path, 0, length) != NULL) {
+    free(path);
+    napi_throw_type_error(env, NULL, "path must be UTF-8 without NUL bytes");
+    return 0;
+  }
+  *out = path;
+  return 1;
+}
+
+static napi_value peer_cred(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1], result, value;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  int fd;
+  if (!argument_count(env, argc, 1) || !fd_arg(env, argv[0], &fd)) return NULL;
+  struct ucred cred;
+  socklen_t length = sizeof(cred);
+  if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cred, &length) < 0) return system_error(env, "SO_PEERCRED");
+  if (length != sizeof(cred)) { napi_throw_error(env, NULL, "SO_PEERCRED returned an invalid length"); return NULL; }
+  CHECK(napi_create_object(env, &result));
+  CHECK(napi_create_int32(env, cred.pid, &value));
+  CHECK(napi_set_named_property(env, result, "pid", value));
+  CHECK(napi_create_uint32(env, cred.uid, &value));
+  CHECK(napi_set_named_property(env, result, "uid", value));
+  CHECK(napi_create_uint32(env, cred.gid, &value));
+  CHECK(napi_set_named_property(env, result, "gid", value));
+  return result;
+}
+
+static napi_value open_at2(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4], result;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  int dirfd;
+  uint32_t flags, resolve;
+  char *path;
+  if (!argument_count(env, argc, 4) || !fd_arg(env, argv[0], &dirfd) || !string_arg(env, argv[1], &path)) return NULL;
+  if (!unsigned_arg(env, argv[2], &flags) || !unsigned_arg(env, argv[3], &resolve)) { free(path); return NULL; }
+  struct open_how how = { .flags = flags, .resolve = resolve };
+  int fd = syscall(SYS_openat2, dirfd, path, &how, sizeof(how));
+  free(path);
+  if (fd < 0) return system_error(env, "openat2");
+  if (napi_create_int32(env, fd, &result) != napi_ok) { close(fd); napi_throw_error(env, NULL, "N-API operation failed"); return NULL; }
+  return result;
+}
+
+static napi_value fd_path(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1], result;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  int fd;
+  if (!argument_count(env, argc, 1) || !fd_arg(env, argv[0], &fd)) return NULL;
+  char link[64];
+  snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
+  size_t size = 256;
+  for (;;) {
+    char *path = malloc(size + 1);
+    if (path == NULL) { napi_throw_error(env, "ENOMEM", "allocating fd path"); return NULL; }
+    ssize_t length = readlink(link, path, size);
+    if (length < 0) { free(path); return system_error(env, "readlink /proc/self/fd"); }
+    if ((size_t)length < size) {
+      path[length] = 0;
+      napi_status status = napi_create_string_utf8(env, path, (size_t)length, &result);
+      free(path);
+      if (status != napi_ok) { napi_throw_error(env, NULL, "N-API operation failed"); return NULL; }
+      return result;
+    }
+    free(path);
+    if (size >= 1024 * 1024) { napi_throw_error(env, "ENAMETOOLONG", "fd path exceeds 1 MiB"); return NULL; }
+    size *= 2;
+  }
+}
+
+static napi_value fd_stat(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1], result, value;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  int fd;
+  if (!argument_count(env, argc, 1) || !fd_arg(env, argv[0], &fd)) return NULL;
+  struct stat st;
+  if (fstat(fd, &st) < 0) return system_error(env, "fstat");
+  CHECK(napi_create_object(env, &result));
+#define NUMBER(name, field) do { CHECK(napi_create_uint32(env, st.field, &value)); CHECK(napi_set_named_property(env, result, name, value)); } while (0)
+  NUMBER("uid", st_uid);
+  NUMBER("gid", st_gid);
+  NUMBER("mode", st_mode);
+  NUMBER("nlink", st_nlink);
+#undef NUMBER
+  CHECK(napi_create_bigint_uint64(env, st.st_dev, &value));
+  CHECK(napi_set_named_property(env, result, "dev", value));
+  CHECK(napi_create_bigint_uint64(env, st.st_ino, &value));
+  CHECK(napi_set_named_property(env, result, "ino", value));
+  return result;
+}
+
+static napi_value send_fds(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3], item;
+  int socket_fd;
+  char *data;
+  uint32_t count;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  if (!argument_count(env, argc, 3) || !fd_arg(env, argv[0], &socket_fd) || !string_arg(env, argv[1], &data)) return NULL;
+  if (napi_get_array_length(env, argv[2], &count) != napi_ok || count > 16 || strlen(data) > 65535) {
+    free(data); napi_throw_range_error(env, NULL, "invalid launcher packet"); return NULL;
+  }
+  char control[CMSG_SPACE(16 * sizeof(int))] = {0};
+  struct iovec iov = { .iov_base = data, .iov_len = strlen(data) };
+  struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1 };
+  if (count) {
+    msg.msg_control = control; msg.msg_controllen = CMSG_SPACE(count * sizeof(int));
+    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
+    cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(count * sizeof(int));
+    for (uint32_t i = 0; i < count; i++) {
+      int fd;
+      CHECK(napi_get_element(env, argv[2], i, &item));
+      if (!fd_arg(env, item, &fd)) { free(data); return NULL; }
+      memcpy((char *)CMSG_DATA(cmsg) + i * sizeof(int), &fd, sizeof(fd));
+    }
+  }
+  ssize_t sent = sendmsg(socket_fd, &msg, MSG_NOSIGNAL | MSG_DONTWAIT);
+  int saved = errno;
+  free(data);
+  if (sent < 0) { errno = saved; return system_error(env, "sendmsg"); }
+  if ((size_t)sent != iov.iov_len) { napi_throw_error(env, "EIO", "short launcher packet"); return NULL; }
+  napi_value result;
+  CHECK(napi_get_undefined(env, &result));
+  return result;
+}
+
+static napi_value recv_fds(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1], result, value, fds;
+  int socket_fd;
+  CHECK(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  if (!argument_count(env, argc, 1) || !fd_arg(env, argv[0], &socket_fd)) return NULL;
+  char data[65536], control[CMSG_SPACE(16 * sizeof(int))] = {0};
+  struct iovec iov = { .iov_base = data, .iov_len = sizeof(data) };
+  struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1, .msg_control = control, .msg_controllen = sizeof(control) };
+  struct pollfd pending = { .fd = socket_fd, .events = POLLIN };
+  int ready = poll(&pending, 1, 1000);
+  if (ready < 0) return system_error(env, "poll launcher packet");
+  if (ready == 0) { errno = ETIMEDOUT; return system_error(env, "launcher packet timed out"); }
+  ssize_t received = recvmsg(socket_fd, &msg, MSG_CMSG_CLOEXEC);
+  if (received < 0) return system_error(env, "recvmsg");
+  int received_fds[16], count = 0;
+  for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+    if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS || cmsg->cmsg_len < CMSG_LEN(0) || (cmsg->cmsg_len - CMSG_LEN(0)) % sizeof(int) != 0 || count + (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int) > 16) goto invalid_packet;
+    int n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
+    for (int i = 0; i < n; i++) memcpy(&received_fds[count++], (char *)CMSG_DATA(cmsg) + i * sizeof(int), sizeof(int));
+  }
+  if (received == 0 || (msg.msg_flags & (MSG_CTRUNC | MSG_TRUNC))) goto invalid_packet;
+  CHECK(napi_create_object(env, &result));
+  CHECK(napi_create_string_utf8(env, data, (size_t)received, &value));
+  CHECK(napi_set_named_property(env, result, "data", value));
+  CHECK(napi_create_array_with_length(env, count, &fds));
+  for (int i = 0; i < count; i++) {
+    CHECK(napi_create_int32(env, received_fds[i], &value));
+    CHECK(napi_set_element(env, fds, i, value));
+  }
+  CHECK(napi_set_named_property(env, result, "fds", fds));
+  return result;
+invalid_packet:
+  for (int i = 0; i < count; i++) close(received_fds[i]);
+  napi_throw_error(env, "EINVAL", "invalid or truncated launcher packet");
+  return NULL;
+}
+
+static napi_value init(napi_env env, napi_value exports) {
+  napi_property_descriptor methods[] = {
+    { "peerCred", NULL, peer_cred, NULL, NULL, NULL, napi_default, NULL },
+    { "openat2", NULL, open_at2, NULL, NULL, NULL, napi_default, NULL },
+    { "fdPath", NULL, fd_path, NULL, NULL, NULL, napi_default, NULL },
+    { "fstat", NULL, fd_stat, NULL, NULL, NULL, napi_default, NULL },
+    { "sendFds", NULL, send_fds, NULL, NULL, NULL, napi_default, NULL },
+    { "recvFds", NULL, recv_fds, NULL, NULL, NULL, napi_default, NULL },
+  };
+  CHECK(napi_define_properties(env, exports, sizeof(methods) / sizeof(methods[0]), methods));
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init)

package/dist/core/profiles/state-block.d.ts

@@ -1,4 +0,0 @@
-/** A live `<profiles count=N>` state element — one `<profile_id> — <name>` line
- *  per profile on this host. Soft-fails via the renderer like other state
- *  blocks. */
-export declare function profilesStateBlock(): string;

package/dist/core/profiles/state-block.js

@@ -1,3 +0,0 @@
-var s=Object.defineProperty;var l=(o,t)=>s(o,"name",{value:t,configurable:!0});import{stateBlock as r}from"../help.js";import{listProfiles as c}from"./manifest.js";function u(){const o=c(),t=20,e=o.slice(0,t).map(i=>`${i.profileId} \u2014 ${i.manifest.name}`).join(`
-`),n=o.length>t?`${e}
-\u2026 ${o.length-t} more; use crtr profile list`:e;return r("profiles",{count:o.length},n)}l(u,"profilesStateBlock");export{u as profilesStateBlock};

package/dist/core/runtime/broker/auth-reload.d.ts

@@ -1,41 +0,0 @@
-import type { AgentSessionServices, ModelRegistry } from '@earendil-works/pi-coding-agent';
-import type { BrokerSdkConfig } from '../launch.js';
-import type { BrokerClient } from './client-registry.js';
-import type { FrameReplies } from './frame-replies.js';
-import type { RebindDriver } from './rebind.js';
-import type { BrokerSession } from './read-ops.js';
-import type { TurnAdmissionGate } from './turn-admission.js';
-type ResolvedLaunchModel = {
-    model: NonNullable<ReturnType<ModelRegistry['find']>>;
-    thinkingLevel: string | undefined;
-} | undefined;
-/**
- * The `reload_auth` frame and the two pieces of work it starts: a model
- * reconcile against freshly re-read credentials, and — when this node is
- * sitting on a recorded provider auth fault — a rewind-and-redrive of the turn
- * that fault killed. Owns the in-flight state both need so a burst of
- * canvas-wide /login fans collapses into one reconcile per generation.
- */
-export type AuthReloadGate = {
-    /** The in-flight reconcile an idle prompt must not overtake, if any. */
-    inFlight(): Promise<void> | undefined;
-    /** Handle a `reload_auth` frame. Open to any client, observers included. */
-    handle(client: BrokerClient): void;
-    /** A session replacement invalidates the reconcile the old one was waiting on. */
-    resetForSession(): void;
-};
-export declare function createAuthReloadGate(deps: {
-    nodeId: string;
-    cfg: BrokerSdkConfig;
-    replies: FrameReplies;
-    rebind: RebindDriver;
-    session: () => BrokerSession;
-    services: () => AgentSessionServices;
-    broadcastModelChanged: (persist?: boolean, pinnedOverride?: boolean, userSelected?: boolean) => Promise<void>;
-    formatModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
-    resolveLaunchModel: (services: AgentSessionServices, cfg: BrokerSdkConfig) => Promise<ResolvedLaunchModel>;
-    /** A reconcile that finally resolves a model releases the held launch prompt. */
-    driveKickoff: () => void;
-    turnAdmission: TurnAdmissionGate;
-}): AuthReloadGate;
-export {};

package/dist/core/runtime/broker/auth-reload.js

@@ -1 +0,0 @@
-var E=Object.defineProperty;var d=(u,s)=>E(u,"name",{value:s,configurable:!0});import{AUTH_FAULT_RECOVERY_BODY as T,formatCard as G}from"../../../shared/generated-context.js";import{envModelIntent as x}from"../../../shared/env.js";import{emitEvent as g}from"../../events/emit.js";import{brokerRecovery as y,mutateBrokerFault as B}from"./daemon-ops.js";import{isUnknownModel as C}from"../model-selection.js";import{announceMessageOrigin as O}from"../stamp/channel.js";function V(u){const{nodeId:s,cfg:m,replies:k,rebind:v,session:p,services:_,broadcastModelChanged:R,formatModelSpec:w,resolveLaunchModel:L,driveKickoff:F,turnAdmission:I}=u;let c=null,h=!1;const a=d((r,e)=>v.installedGeneration()!==r||p()!==e,"supersededBy"),M=d(async(r,e,t)=>{if(await t.modelRuntime.refresh({allowNetwork:!1}),a(r,e))return;const i=e.model===void 0||C(e.model),o=m.modelExact!==!0&&m.modelProviderPinned!==!0&&(x()??"").trim()!=="";if(i||o){const n=await L(t,m);if(a(r,e))return;if(n!==void 0){const l=w(e.model,e.thinkingLevel),f=w(n.model,n.thinkingLevel);if(f!==null&&f!==l){if(await e.setModel(n.model),a(r,e))return;e.setThinkingLevel(n.thinkingLevel??"off")}}}a(r,e)||(await R(),F())},"runAuthReload"),A=d(()=>{const r=v.installedGeneration(),e=c;if(e!==null&&e.generation===r)return e.promise;if(r===void 0)return;const t=p(),i=_(),o=M(r,t,i).catch(l=>{g({level:"warn",event:"broker.auth_reload.reconcile_failed",error:l})}),n={generation:r,promise:o};return c=n,o.finally(()=>{c===n&&(c=null)}),o},"startAuthReload"),b=d(r=>{const e=v.installedGeneration(),t=p();t.isStreaming||h||(h=!0,(async()=>{try{const i=(await y(s)).fault;if(i?.link!=="pi\u2192provider"||i.kind!=="auth"||(r!==void 0&&await r,a(e,t)))return;const o=i.anchor_entry_id;if(o!==void 0)try{if((t.sessionManager.getLeafId?.()??null)!==o&&await t.navigateTree(o),a(e,t))return}catch(l){g({level:"warn",event:"broker.auth_fault.rewind_skipped",error:l})}const n=(await y(s)).fault;if(a(e,t)||t.isStreaming||n?.link!=="pi\u2192provider"||n.kind!=="auth"||n.since!==i.since)return;await I.admit(async l=>{if(a(e,t)||t.isStreaming)return l(),Promise.resolve();await B(s,{op:"clear",link:"pi\u2192provider"});const f=G("recovery",{},T);return O(f,{type:"runtime",kind:"recovery"}),t.prompt(f,{preflightResult:l})})}catch(i){g({level:"error",event:"broker.auth_fault.redrive_failed",error:i})}finally{h=!1}})())},"redriveAuthFault");return{inFlight:d(()=>c?.promise,"inFlight"),handle(r){try{k.ackTo(r,"reload_auth"),b(A())}catch(e){k.engineErrorTo(r)(e)}},resetForSession(){c=null}}}d(V,"createAuthReloadGate");export{V as createAuthReloadGate};

package/dist/core/substrate/cli-context-delivery.d.ts

@@ -1,22 +0,0 @@
-import { type ContextExposureState, type ExposureTarget } from './injected-store.js';
-import type { NodeConfigSubject } from './subject-fields.js';
-export type CliContextDeliveryOutcome = 'stateless' | 'recorded' | 'unrecorded';
-export interface CliContextDelivery<T> {
-    result: T;
-    outcome: CliContextDeliveryOutcome;
-    diagnostic?: string;
-}
-export interface CliContextDeliveryOptions<T> {
-    nodeId: string | undefined;
-    /** Explicit memory reads remain useful without a daemon: gated attachments
-     * skip while ungated ones render, exactly as before this shared boundary. */
-    allowUnavailableSubject?: boolean;
-    loadSubject?: (nodeId: string) => Promise<NodeConfigSubject | null>;
-    loadState?: (nodeId: string) => ContextExposureState;
-    saveState?: (nodeId: string, state: ContextExposureState) => void;
-    render: (subject: NodeConfigSubject | null, target: ExposureTarget) => T | Promise<T>;
-}
-/** Render one CLI-owned delivery batch. The renderer owns event routing and
- * exposure registration; this boundary owns subject lookup and the one
- * load/clone/render/save ledger transaction shared by CLI callers. */
-export declare function renderCliContextDelivery<T>(opts: CliContextDeliveryOptions<T>): Promise<CliContextDelivery<T>>;

package/dist/core/substrate/cli-context-delivery.js

@@ -1 +0,0 @@
-var s=Object.defineProperty;var n=(t,e)=>s(t,"name",{value:e,configurable:!0});import{localClient as f}from"../../api/node-transport.js";import{CrtrError as x}from"../errors.js";import{cloneContextExposureState as m,emptyContextExposureState as S,exposureTarget as c,loadContextExposureState as b,saveContextExposureState as w}from"./injected-store.js";function a(t,e){const r=e instanceof Error?e.message:e===void 0?void 0:String(e);return new x("context_delivery_failed",r===void 0?t:`${t}: ${r}`,void 0,{next:"The displayed file content remains available; retry context delivery in a live node when the runtime is reachable."})}n(a,"deliveryError");async function y(t){return await f({autostart:!1,coldStartPollWindowMs:0}).nodeSubject(t)}n(y,"nodeSubject");async function E(t){const e=t.nodeId?.trim();if(e===void 0||e==="")return{result:await t.render(null,c(S(),"transcript")),outcome:"stateless"};let r;try{r=await(t.loadSubject??y)(e)}catch(o){if(t.allowUnavailableSubject!==!0)throw a(`could not load context subject for node ${e}`,o);r=null}if(r===null&&t.allowUnavailableSubject!==!0)throw a(`could not load context subject for node ${e}`);let d;try{d=(t.loadState??b)(e)}catch(o){throw a(`could not load context exposure state for node ${e}`,o)}const l=m(d),i=await t.render(r,c(l,"transcript"));try{return(t.saveState??w)(e,l),{result:i,outcome:"recorded"}}catch(o){const u=o instanceof Error?o.message:String(o);return{result:i,outcome:"unrecorded",diagnostic:`Context was delivered but not recorded for node ${e}: ${u}`}}}n(E,"renderCliContextDelivery");export{E as renderCliContextDelivery};