totemlayer 0.1.97 → 0.1.115

package/bin/strict-installation.mjs

@@ -1,6 +1,7 @@
 import { parseArgs } from "node:util";
 import { GUIDE_UNAVAILABLE, runStrictSetup } from "./strict-setup.mjs";
 import { readReleaseSetupGuide } from "./setup-guide.mjs";
+import { NATIVE_INSTALL_PROVIDERS } from "./configured-native-installation.mjs";
 
 export const STRICT_INSTALL_HELP = `Install Totem with every required verification
 
@@ -9,6 +10,15 @@ export const STRICT_INSTALL_HELP = `Install Totem with every required verificati
     [--device-login --no-browser]
   totem install --read-guide
   totem install --status
+  totem install --provider pi|hermes|opencode|kilo|claude --native-config /private/binding.json
+    --session CURRENT_NATIVE_SESSION --model CURRENT_MODEL [--status] [--json]
+  totem install --provider claude --native-config /private/binding.json
+    --session CURRENT_NATIVE_SESSION --model CURRENT_MODEL --agent-id UUID --environment PRODUCTION|SANDBOX
+    --device-login [--no-browser] [--wait-seconds 1200] [--json]
+
+Native profiles use their existing sign-in and a private owner-prepared binding.
+This registers/resumes the exact native receiver; it reports incomplete until live
+receiving, restart, peer and website-owner acceptance are separately verified.
 
 Run inside the intended agent's command-capable host. The current native session and
 model must be verified; an installed client is never selected as a substitute.
@@ -37,6 +47,7 @@ export async function strictInstallationMain(args = [], options = {}) {
         environment: { type: "string" },
         "base-url": { type: "string" },
         session: { type: "string" },
+        "native-config": { type: "string" },
         model: { type: "string" },
         "wait-seconds": { type: "string", default: "1200" },
         "read-guide": { type: "boolean" },
@@ -94,8 +105,12 @@ export async function strictInstallationMain(args = [], options = {}) {
         /tn_(?:live|test)_/.test(values.model))
     )
       throw new Error();
-    if (values.session && !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(values.session))
+    const sessionPattern = values.provider === "hermes" ? /^\d{8}_\d{6}_[a-f0-9]{6}$/
+      : ["opencode", "kilo"].includes(values.provider) ? /^ses_[A-Za-z0-9]{12,80}$/
+        : /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
+    if (values.session && !sessionPattern.test(values.session))
       throw new Error();
+    if (values["native-config"] && !NATIVE_INSTALL_PROVIDERS.includes(values.provider)) throw new Error();
     const env = options.env ?? process.env;
     flags = {
       provider: values.provider ?? (env.CODEX_THREAD_ID ? "codex" : undefined),
@@ -106,10 +121,12 @@ export async function strictInstallationMain(args = [], options = {}) {
       model: values.model,
       waitSeconds,
       json: values.json === true,
+      ...(values["native-config"] ? { nativeConfig: values["native-config"] } : {}),
     };
     if (values["device-login"]) flags.deviceLogin = true;
     if (values["no-browser"]) flags.noBrowser = true;
-    if (values.status) {
+    if (values.status && flags.nativeConfig) flags.status = true;
+    else if (values.status) {
       flags.sessionId ??= env.CODEX_THREAD_ID;
       const { readStrictSetupJob } = await import("./strict-setup-jobs.mjs");
       const publicStatus = { ...(await readStrictSetupJob(flags, env)) };
@@ -130,6 +147,15 @@ export async function strictInstallationMain(args = [], options = {}) {
     return 2;
   }
   const write = async (value) => stdout.write(JSON.stringify(value) + "\n");
+  if (flags.nativeConfig) {
+    try {
+      const { installConfiguredNativeReceiver } = await import("./configured-native-installation.mjs");
+      await write({ ...await installConfiguredNativeReceiver(flags, { ...options, write }), complete: false });
+    } catch (error) {
+      await write({ complete: false, state: "incomplete", code: /^[A-Z][A-Z0-9_]{0,79}$/.test(error.code ?? "") ? error.code : "NATIVE_INSTALL_FAILED" });
+    }
+    return 2;
+  }
   if (!options.adapter && !options.foreground && flags.provider === "codex") {
     // Return before readiness needs a model turn in this same native chat.
     const adapter = (await import("./strict-codex-adapter.mjs")).createStrictCodexAdapter(flags, {
@@ -190,7 +216,7 @@ export async function strictInstallationMain(args = [], options = {}) {
           readGuide: readReleaseSetupGuide,
           async inspect() {
             throw Object.assign(new Error(), {
-              code: flags.provider ? "HOST_ADAPTER_UNSUPPORTED" : "EXACT_NATIVE_HOST_REQUIRED",
+              code: ["pi", "hermes", "opencode", "kilo"].includes(flags.provider) ? "NATIVE_CONFIGURATION_REQUIRED" : flags.provider ? "HOST_ADAPTER_UNSUPPORTED" : "EXACT_NATIVE_HOST_REQUIRED",
             });
           },
         });

package/bin/supervisor-watchdog.mjs

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { privateRead, privateWrite } from "./runtime-installation.mjs";
+
+/** The launcher owns this ChildProcess; never discover or signal a saved PID here. */
+export function watchSupervisorChild(child, directory, options = {}) {
+  const heartbeatFile = options.heartbeatFile ?? "supervisor.json";
+  if (!["supervisor.json", "status.json"].includes(heartbeatFile)) throw new Error("Invalid supervisor heartbeat file.");
+  const timeoutMs = options.timeoutMs ?? 300000;
+  const started = Date.now();
+  let checking = false, stopped = false, terminating = false, force;
+  const alive = () => child.exitCode === null && child.signalCode === null;
+  const stop = () => {
+    stopped = true;
+    clearInterval(timer);
+    clearTimeout(force);
+    child.removeListener("exit", stop);
+    child.removeListener("error", stop);
+  };
+  const timer = setInterval(async () => {
+    if (stopped || checking || terminating || !alive()) return;
+    checking = true;
+    try {
+      const state = await privateRead(join(directory, heartbeatFile)).catch(() => null);
+      if (stopped || !alive()) return;
+      const now = Date.now(), updated = Date.parse(state?.updatedAt);
+      // A deliberately paused dedicated inbox is quiet by design. The stored
+      // PID must still match the child this launcher owns, never another job.
+      if (options.allowPaused === true && state?.pid === child.pid && state.state === "paused") return;
+      if (now - started < timeoutMs ||
+          (state?.pid === child.pid && Number.isFinite(updated) && updated <= now + 5000 && now - updated < timeoutMs)) return;
+      terminating = true;
+      void privateWrite(join(directory, "supervisor-watchdog.json"), {
+        code: "SUPERVISOR_HEARTBEAT_TIMEOUT", pid: child.pid, updatedAt: new Date(now).toISOString(),
+      }).catch(() => {});
+      child.kill("SIGTERM");
+      force = setTimeout(() => { if (alive()) child.kill("SIGKILL"); }, options.graceMs ?? 5000);
+      force.unref();
+    } finally { checking = false; }
+  }, options.intervalMs ?? 15000);
+  timer.unref();
+  child.once("exit", stop);
+  child.once("error", stop);
+  return stop;
+}

package/bin/windows-private-path.mjs

@@ -1,9 +1,10 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
+import { createConnection } from "node:net";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
 import { join, resolve } from "node:path";
 import { lstat } from "node:fs/promises";
 
-const execute = promisify(execFile);
 export function validateWindowsPrivateAcl(snapshot) {
   const sid = snapshot?.sid;
   if (typeof sid !== "string" || !/^S-1-(?:\d+-){1,14}\d+$/.test(sid))
@@ -54,36 +55,230 @@ export function validateWindowsPrivateAcl(snapshot) {
     throw new Error("The private Windows path or its parent can be replaced by another principal.");
 }
 
+// Keep the native process, never its results. Every request reads the current
+// file and all ancestor ACLs again, including after a permission change.
+const inspectionScript = (pipeName) => `$ErrorActionPreference='Stop'
+[Console]::Error.WriteLine('TOTEM_ACL_START')
+function Rules($acl) { @($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]) | ForEach-Object { @{sid=$_.IdentityReference.Value;rights=[int64]$_.FileSystemRights;type=$_.AccessControlType.ToString();inheritOnly=[bool]($_.PropagationFlags -band [Security.AccessControl.PropagationFlags]::InheritOnly)} }) }
+$security=[IO.Pipes.PipeSecurity]::new()
+$owner=[Security.Principal.WindowsIdentity]::GetCurrent().User
+$security.SetOwner($owner)
+$security.SetAccessRuleProtection($true,$false)
+$security.AddAccessRule([IO.Pipes.PipeAccessRule]::new($owner,[IO.Pipes.PipeAccessRights]::FullControl,[Security.AccessControl.AccessControlType]::Allow))
+$pipe=[IO.Pipes.NamedPipeServerStream]::new('${pipeName}',[IO.Pipes.PipeDirection]::InOut,1,[IO.Pipes.PipeTransmissionMode]::Byte,[IO.Pipes.PipeOptions]::None,4096,4096,$security)
+[Console]::Error.WriteLine('TOTEM_ACL_PIPE_READY')
+try {
+$pipe.WaitForConnection()
+[Console]::Error.WriteLine('TOTEM_ACL_CONNECTED')
+$hello=[Text.Encoding]::UTF8.GetBytes('{"id":0,"nonce":"'+$env:TOTEM_ACL_CHALLENGE+'"}'+"\`n")
+$pipe.Write($hello,0,$hello.Length)
+[Console]::Error.WriteLine('TOTEM_ACL_HELLO_SENT')
+[byte[]]$buffer=[Array]::CreateInstance([byte],4096)
+[Console]::Error.WriteLine('TOTEM_ACL_BUFFER_READY')
+$pending=''
+function Send-Frame($frame) {
+  $bytes=[Text.Encoding]::UTF8.GetBytes(($frame | ConvertTo-Json -Depth 9 -Compress)+"\`n")
+  $pipe.Write($bytes,0,$bytes.Length)
+}
+while ($true) {
+  while (($end=$pending.IndexOf("\`n")) -lt 0) {
+    [Console]::Error.WriteLine('TOTEM_ACL_READING')
+    $length=$pipe.Read($buffer,0,$buffer.Length)
+    if ($length -eq 0) { return }
+    [Console]::Error.WriteLine('TOTEM_ACL_FRAME_READ')
+    $pending += [Text.Encoding]::ASCII.GetString($buffer,0,$length)
+    if ($pending.Length -gt 65536) { throw 'ACL request too large' }
+  }
+  $line=$pending.Substring(0,$end)
+  $pending=$pending.Substring($end+1)
+  [Console]::Error.WriteLine('TOTEM_ACL_REQUEST_RECEIVED')
+  $request=$null
+  try {
+    $request=$line | ConvertFrom-Json
+    $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($request.path))
+    $sid=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+    $item=Get-Item -LiteralPath $path -Force
+    $acl=Get-Acl -LiteralPath $path
+    $parents=@(); $parent=Split-Path -LiteralPath $path
+    while ($parent) {
+      $p=Get-Item -LiteralPath $parent -Force
+      $parentAcl=Get-Acl -LiteralPath $parent
+      $parents+=@{owner=$parentAcl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($p.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $parentAcl)}
+      $next=Split-Path -LiteralPath $parent
+      if ($next -eq $parent) { break }; $parent=$next
+    }
+    $snapshot=@{sid=$sid;owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($item.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $acl);ancestors=$parents}
+     Send-Frame @{id=$request.id;snapshot=$snapshot}
+     [Console]::Error.WriteLine('TOTEM_ACL_RESULT_SENT')
+  } catch {
+     Send-Frame @{id=$request.id;error='ACL inspection failed'}
+  }
+}
+} finally { $pipe.Dispose() }
+`;
+
+export function createWindowsAclReader(options = {}) {
+  let worker,
+    nextId = 0;
+  const unavailable = () => new Error("The Windows access rules could not be verified.");
+  function stop(current) {
+    if (current.stopped) return;
+    current.stopped = true;
+    if (worker === current) worker = undefined;
+    clearTimeout(current.idle);
+    clearTimeout(current.reconnect);
+    for (const { timer, reject } of current.pending.values()) {
+      clearTimeout(timer);
+      reject(unavailable());
+    }
+    current.pending.clear();
+    current.socket?.destroy();
+    current.child?.kill();
+  }
+  function start() {
+    const environment = options.environment ?? process.env;
+    const systemRoot = options.systemRoot ?? environment.SystemRoot ?? environment.SYSTEMROOT;
+    if (!systemRoot) throw new Error("The Windows system directory could not be verified.");
+    const name = `totem-acl-${process.pid}-${randomUUID()}`;
+    const nonce = randomUUID();
+    const current = {
+      pending: new Map(),
+      buffer: "",
+      decoder: new StringDecoder("utf8"),
+      nonce,
+      stopped: false,
+      authenticated: false,
+    };
+    worker = current;
+    const child = (options.spawn ?? spawn)(
+      join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(inspectionScript(name), "utf16le").toString("base64"),
+      ],
+      {
+        // The encoded command uses a protected native pipe independently of stdin;
+        // no file paths or secrets are written to stdio.
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+        env: {
+          ...Object.fromEntries(
+            Object.entries(environment).filter(([name]) =>
+              /^(PATH|PATHEXT|COMSPEC|TEMP|TMP|USERPROFILE|HOMEDRIVE|HOMEPATH|APPDATA|LOCALAPPDATA|PROGRAMDATA|PROGRAMFILES|PROGRAMFILES\(X86\)|PSMODULEPATH|SYSTEMDRIVE|USERNAME|USERDOMAIN)$/i.test(
+                name,
+              ),
+            ),
+          ),
+          SystemRoot: systemRoot,
+          windir: systemRoot,
+          TOTEM_ACL_CHALLENGE: nonce,
+        },
+      },
+    );
+    current.child = child;
+    child.unref();
+    child.stderr?.unref?.();
+    let diagnostics = "";
+    child.stderr?.on("data", (chunk) => {
+      diagnostics = (diagnostics + chunk.toString()).slice(-4096);
+      for (const line of diagnostics.split(/\r?\n/).slice(0, -1))
+        if (/^TOTEM_ACL_[A-Z_]+$/.test(line)) options.onDiagnostic?.(line);
+      diagnostics = diagnostics.slice(diagnostics.lastIndexOf("\n") + 1);
+    });
+    child.on("error", () => stop(current));
+    child.on("close", () => stop(current));
+    const connect = () => {
+      if (current.stopped) return;
+      const socket = (options.createConnection ?? createConnection)({
+        path: "\\\\.\\pipe\\" + name,
+      });
+      current.socket = socket;
+      // Pending request timers keep the owner alive. Owner exit closes the pipe
+      // and the native reader exits; idle inspectors cannot prolong a CLI run.
+      socket.unref();
+      let retry = false;
+      socket.on("error", (error) => {
+        if (/^[A-Z_]{1,40}$/.test(error.code ?? "")) options.onDiagnostic?.(error.code);
+        if (!current.authenticated && error.code === "ENOENT") {
+          retry = true;
+          current.reconnect = setTimeout(connect, 25);
+          current.reconnect.unref();
+        } else stop(current);
+      });
+      socket.on("close", () => {
+        if (!retry) stop(current);
+      });
+      socket.on("data", (chunk) => {
+        if (current.stopped) return;
+        current.buffer += current.decoder.write(chunk);
+        if (Buffer.byteLength(current.buffer) > 262144) return stop(current);
+        let end;
+        while ((end = current.buffer.indexOf("\n")) >= 0) {
+          const line = current.buffer.slice(0, end).replace(/^\uFEFF/, "");
+          current.buffer = current.buffer.slice(end + 1);
+          let response;
+          try {
+            response = JSON.parse(line);
+          } catch {
+            return stop(current);
+          }
+          if (!current.authenticated) {
+            if (
+              response.id !== 0 ||
+              typeof response.nonce !== "string" ||
+              response.nonce.length !== nonce.length ||
+              !/^[a-f0-9-]{36}$/.test(response.nonce) ||
+              !timingSafeEqual(Buffer.from(response.nonce), Buffer.from(nonce))
+            )
+              return stop(current);
+            current.authenticated = true;
+            options.onDiagnostic?.("AUTHENTICATED");
+            for (const pending of current.pending.values()) socket.write(pending.request);
+            options.onDiagnostic?.("REQUEST_SENT");
+            continue;
+          }
+          const pending = current.pending.get(response.id);
+          if (!pending) return stop(current);
+          clearTimeout(pending.timer);
+          current.pending.delete(response.id);
+          options.onDiagnostic?.("RESULT_RECEIVED");
+          if (response.error || !response.snapshot) pending.reject(unavailable());
+          else pending.resolve(response.snapshot);
+        }
+        if (!current.pending.size) {
+          current.idle = setTimeout(() => stop(current), options.idleMs ?? 30000);
+          current.idle.unref();
+        }
+      });
+    };
+    connect();
+    return current;
+  }
+  return {
+    read(path) {
+      const encodedPath = Buffer.from(resolve(path), "utf8").toString("base64");
+      const current = worker ?? start();
+      clearTimeout(current.idle);
+      if (current.pending.size >= 1024) return Promise.reject(unavailable());
+      const id = ++nextId;
+      return new Promise((resolveRequest, reject) => {
+        const timer = setTimeout(() => stop(current), options.timeoutMs ?? 10000);
+        const request = JSON.stringify({ id, path: encodedPath }) + "\n";
+        current.pending.set(id, { resolve: resolveRequest, reject, timer, request });
+        if (current.authenticated) current.socket.write(request);
+      });
+    },
+    close() {
+      if (worker) stop(worker);
+    },
+  };
+}
+
+const reader = createWindowsAclReader();
 export async function assertWindowsPrivatePath(path) {
   if (process.platform !== "win32") return;
   await lstat(path); // Preserve ENOENT for callers that create a new private file.
-  const encoded = Buffer.from(resolve(path), "utf8").toString("base64");
-  const script = `$ErrorActionPreference='Stop'
-$path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))
-$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value
-function Rules($acl) { @($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]) | ForEach-Object { @{sid=$_.IdentityReference.Value;rights=[int64]$_.FileSystemRights;type=$_.AccessControlType.ToString();inheritOnly=[bool]($_.PropagationFlags -band [Security.AccessControl.PropagationFlags]::InheritOnly)} }) }
-$item=Get-Item -LiteralPath $path -Force
-$acl=Get-Acl -LiteralPath $path
-$parents=@(); $parent=Split-Path -LiteralPath $path
-while ($parent) {
-  $p=Get-Item -LiteralPath $parent -Force
-  $parentAcl=Get-Acl -LiteralPath $parent
-  $parents+=@{owner=$parentAcl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($p.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $parentAcl)}
-  $next=Split-Path -LiteralPath $parent
-  if ($next -eq $parent) { break }; $parent=$next
-}
-@{sid=$sid;owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($item.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $acl);ancestors=$parents} | ConvertTo-Json -Depth 8 -Compress`;
-  const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
-  if (!systemRoot) throw new Error("The Windows system directory could not be verified.");
-  const { stdout } = await execute(
-    join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-EncodedCommand",
-      Buffer.from(script, "utf16le").toString("base64"),
-    ],
-    { timeout: 10000, maxBuffer: 262144, windowsHide: true },
-  );
-  validateWindowsPrivateAcl(JSON.parse(stdout.replace(/^\uFEFF/, "")));
+  validateWindowsPrivateAcl(await reader.read(path));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.97",
+  "version": "0.1.115",
   "description": "Connect AI agents to Totem Network for discovery, messaging, and shared work.",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
   "homepage": "https://totemlayer.com",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/totemlayer/Totem.git"
+    "url": "git+https://github.com/linbrandon4/Totem.git"
   },
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {