@cotal-ai/manager 0.46.0 → 0.47.0

package/dist/manager.js

@@ -1,10 +1,10 @@
 import { execFile } from "node:child_process";
 import { createHash, randomUUID, randomBytes } from "node:crypto";
 import { hostname } from "node:os";
-import { connect, credsAuthenticator } from "@nats-io/transport-node";
+import { credsAuthenticator } from "@nats-io/transport-node";
 import { existsSync, lstatSync, readFileSync, rmSync } from "node:fs";
 import { join, dirname, resolve } from "node:path";
-import { CotalEndpoint, DEFAULT_SERVER, DEV_OWNER, MANAGER_LEASE_RENEW_MS, STANDING_RENEWABLE_TTL_SEC, agentFilePath, clearSpaceHistory, connectorServers, spawnEnvAllow, deprovisionAgent, firstFreeName, spawnNameError, idFromCreds, inspectCredHealth, loadAgentFile, listPersonaCatalog, personaCatalogDescription, personaCatalogReadable, loadCotalConfig, mintCreds, mintLifecycleUid, mkSecretDir, newIdentity, actionContext, parsePrincipalKey, parseShareSelection, principalKey, probeConnect, provisionAgent, provisionAgentDurables, registry, resolveAuthProvider, saveAgentFile, subjectMatches, AUTH_ENDPOINT, EP_CMD_RETIRE_LIFECYCLE, epRequestSubject, epCallerReplyFilter, parseEpSubject, controlServiceSubject, eventChannelPrincipal, } from "@cotal-ai/core";
+import { CotalEndpoint, DEFAULT_SERVER, DEV_OWNER, MANAGER_LEASE_RENEW_MS, STANDING_RENEWABLE_TTL_SEC, agentFilePath, clearSpaceHistory, dialerFor, connectorServers, spawnEnvAllow, deprovisionAgent, firstFreeName, spawnNameError, idFromCreds, inspectCredHealth, loadAgentFile, listPersonaCatalog, personaCatalogDescription, personaCatalogReadable, loadCotalConfig, mintCreds, mintLifecycleUid, mkSecretDir, newIdentity, actionContext, parsePrincipalKey, parseShareSelection, principalKey, probeConnect, provisionAgent, provisionAgentDurables, registry, resolveAuthProvider, saveAgentFile, subjectMatches, AUTH_ENDPOINT, EP_CMD_RETIRE_LIFECYCLE, epRequestSubject, epCallerReplyFilter, parseEpSubject, controlServiceSubject, eventChannelPrincipal, } from "@cotal-ai/core";
 import { agentAuthState, agentCredsDir, agentLifecycleSecretFilePaths, agentSecretFilePaths, agentSecretKeyForFile, authDir, connectorInstallHint, DEFAULT_CONNECTOR, defaultAgentType, DELIVERY_CREDS_KIND, extensionConnectors, findCotalRoot, getSpaceAuth, hasUserAuthState, loadExtensionsManifest, loadManagerInstanceIdentity, loadMeshes, manifestExtensionNames, materializeFromManifest, materializeSecretToFile, MEMBERSHIP_RW_CREDS_KIND, mergeLaunchOptions, remintDaemonCreds, resolveOnPath, saveManagerInstanceIdentity, spaceMaterialKey, SYSTEM_CREDS_FILES, userAuthStateDir, workspaceSecretStore, writeRenewalRecord } from "@cotal-ai/workspace";
 import { createRuntime, requireRuntimeAdopt, } from "./runtime/index.js";
 import { AttachEndpoint } from "./attach-endpoint.js";
@@ -462,6 +462,17 @@ export class Manager {
     resumeDurableCommitToken;
     resumedAgentNames = new Set();
     remoteAuthority;
+    /** Every broker dial this manager makes, through ONE transport decision.
+     *
+     *  `this.servers` is whatever the mesh record held (`cotal supervise` reads it from there), so it
+     *  can be a `ws://`/`wss://` broker published through an HTTPS edge. The raw node transport
+     *  refuses such a URL instead of dialing it, so the scheme picks the dialer here rather than at
+     *  thirteen call sites. `dialerFor` also owns the websocket transport's options, which is why
+     *  callers below still pass their own auth options unchanged. */
+    dial(opts) {
+        const servers = this.servers ?? DEFAULT_SERVER;
+        return dialerFor(servers)({ ...opts, servers });
+    }
     constructor(opts) {
         this.space = opts.space;
         this.servers = opts.servers;
@@ -1154,8 +1165,6 @@ export class Manager {
     async awaitHandleExit(handle) {
         if (!handle.waitForExit)
             throw new Error(`runtime "${handle.kind}" cannot prove child exit (AgentHandle.waitForExit is not implemented)`);
-        if (handle.status() === "exited")
-            return;
         await withTimeout(handle.waitForExit(), this.preserveStopTimeoutMs, `child did not exit within ${this.preserveStopTimeoutMs}ms`);
         if (handle.status() !== "exited")
             throw new Error(`runtime "${handle.kind}" reported exit completion but status is still running`);
@@ -2540,7 +2549,7 @@ export class Manager {
             const creds = await mintCreds(this.auth, newIdentity(), "retirement-requester", {
                 retirementRequester: { ...caller, target: { owner: target.owner, actor: target.actor, lifecycleUid: a.lifecycleUid } },
             });
-            const nc = await connect({ servers: this.servers ?? DEFAULT_SERVER, authenticator: credsAuthenticator(new TextEncoder().encode(creds)), maxReconnectAttempts: 0 });
+            const nc = await this.dial({ authenticator: credsAuthenticator(new TextEncoder().encode(creds)), maxReconnectAttempts: 0 });
             try {
                 // §13.2 nonce: >=128 bits of CSPRNG entropy, base64url (the `endpoint-invoke` idiom).
                 const nonce = randomBytes(24).toString("base64url");
@@ -4444,7 +4453,12 @@ export class Manager {
                 // └──────────────────────────────────────────────────────────────────────────────────────┘
                 const deliberate = a.terminalizing === true;
                 void (async () => {
-                    const tail = this.tail(await s.backlog());
+                    // waitForExit may close the attach stream before this snapshot
+                    let tail = "";
+                    try {
+                        tail = this.tail(await s.backlog());
+                    }
+                    catch { }
                     if (opts.reapOnExit !== false)
                         this.onAgentExit(a);
                     // A DELIBERATE STOP IS NOT A LAUNCH FAILURE. The despawn path owns this goal's terminal
@@ -4569,7 +4583,7 @@ export class Manager {
         const creds = await mintCreds(this.auth, identity, "lifecycle-executor", {
             lifecycleExecutor: { owner: pin.owner, actor: pin.actor, lifecycleUid: pin.lifecycleUid, alias: pin.alias },
         });
-        const nc = await connect({ servers: this.servers ?? DEFAULT_SERVER, ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
+        const nc = await this.dial({ ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
         try {
             const kvm = new Kvm(nc);
             const recordsKv = await kvm.open(recordsBucket(this.space));
@@ -4594,7 +4608,7 @@ export class Manager {
             : undefined);
         if (!creds)
             throw new Error("withEndpointServeExecutor: no scoped executor authority (an open mesh must use the bare path)");
-        const nc = await connect({ servers: this.servers ?? DEFAULT_SERVER, ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
+        const nc = await this.dial({ ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
         try {
             const kvm = new Kvm(nc);
             return await fn({ recordsKv: await kvm.open(recordsBucket(this.space)), authKv: await kvm.open(epAuthBucket(this.space)), nc });
@@ -4610,7 +4624,7 @@ export class Manager {
     async withOpenServeConnection(fn) {
         if (this.auth)
             throw new Error("withOpenServeConnection: an auth mesh must use the scoped endpoint-serve executor");
-        const nc = await connect({ servers: this.servers ?? DEFAULT_SERVER, maxReconnectAttempts: 0 });
+        const nc = await this.dial({ maxReconnectAttempts: 0 });
         try {
             const kvm = new Kvm(nc);
             // An open mesh may be a RAW broker (no `cotal up` provisioning ran), and `Kvm.open` binds
@@ -4629,7 +4643,7 @@ export class Manager {
         return {
             instanceId: this.managerInstanceId,
             runtime: this.runtime.kind,
-            custody: "legacy",
+            custody: process.platform === "linux" && this.runtime.kind === "pty" ? "custodied" : "legacy",
             agentCount: this.agents.size,
             uptimeMs: Date.now() - this.startedAtMs,
             connectors: this.connectorStatuses.map((row) => ({ ...row, binaries: { ...row.binaries } })),
@@ -4710,8 +4724,7 @@ export class Manager {
                 creds: remote.serveCreds,
             };
             const enc = new TextEncoder();
-            const nc = await connect({
-                servers: this.servers ?? DEFAULT_SERVER,
+            const nc = await this.dial({
                 authenticator: (nonce) => credsAuthenticator(enc.encode(state.creds))(nonce),
                 inboxPrefix: `_INBOX_${state.identity.id}`,
                 maxReconnectAttempts: -1,
@@ -4744,7 +4757,7 @@ export class Manager {
         {
             // Open mesh: the bare connection holds the rights (there is no credential system to mint from).
             const provCreds = auth ? await mintCreds(auth, newIdentity(), "provisioner") : undefined;
-            const provNc = await connect({ servers: this.servers ?? DEFAULT_SERVER, ...standaloneConnectOpts({ creds: provCreds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
+            const provNc = await this.dial({ ...standaloneConnectOpts({ creds: provCreds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
             try {
                 // P2 item 2: the manager now WRITES goal facts (EPF) + progress events (EPE), so the §13.12
                 // endpoint streams must exist. Nothing provisioned them before spawn-as-action (no endpoint
@@ -4889,8 +4902,7 @@ export class Manager {
         // registered surface for its whole incarnation.
         const state = { handle: undefined, nc: undefined, identity: serveIdentity, grant, creds };
         const enc = new TextEncoder();
-        const nc = await connect({
-            servers: this.servers ?? DEFAULT_SERVER,
+        const nc = await this.dial({
             // Open mesh: a bare serve connection (no credential exists; the broker enforces nothing).
             ...(creds !== undefined ? { authenticator: (nonce) => credsAuthenticator(enc.encode(state.creds))(nonce) } : {}),
             inboxPrefix: `_INBOX_${serveIdentity.id}`,
@@ -4985,8 +4997,7 @@ export class Manager {
         // The mutable holder captured by the authenticator (mirrors the serve connection): a half-TTL
         // renewal updates `gw.creds` and the next (re)connect presents the refreshed credential.
         const gw = { nc: undefined, ctx: undefined, creds: (this.auth || this.remoteAuthority) ? this.goalWriterCreds : undefined, identity };
-        const nc = await connect({
-            servers: this.servers ?? DEFAULT_SERVER,
+        const nc = await this.dial({
             ...((this.auth || this.remoteAuthority) ? { authenticator: (nonce) => credsAuthenticator(enc.encode(gw.creds))(nonce) } : {}),
             inboxPrefix: `_INBOX_${identity.id}`,
             maxReconnectAttempts: -1,
@@ -5091,8 +5102,7 @@ export class Manager {
         // The mutable holder captured by the authenticator (mirrors the goal-writer): a half-TTL renewal
         // updates `sw.creds` and the next (re)connect presents the refreshed credential.
         const sw = { nc: undefined, creds: (this.auth || this.remoteAuthority) ? this.sessionLedgerCreds : undefined };
-        const nc = await connect({
-            servers: this.servers ?? DEFAULT_SERVER,
+        const nc = await this.dial({
             ...((this.auth || this.remoteAuthority) ? { authenticator: (nonce) => credsAuthenticator(enc.encode(sw.creds))(nonce) } : {}),
             inboxPrefix: `_INBOX_${identity.id}`,
             maxReconnectAttempts: -1,
@@ -5263,7 +5273,7 @@ export class Manager {
                 // FAIL LOUD: there is deliberately no shared connection to fall back to. Serving a session
                 // without its own credential is exactly the standing-writer shape this design removes.
                 const opts = (this.auth || this.remoteAuthority) ? standaloneConnectOpts({ creds: cred.creds, /* not yet wired to a recorded transport */ tls: false }) : {};
-                return connect({ servers: this.servers ?? DEFAULT_SERVER, ...opts, maxReconnectAttempts: -1 });
+                return this.dial({ ...opts, maxReconnectAttempts: -1 });
             },
             revoke: async (credentialId) => {
                 if (!this.auth && !this.remoteAuthority)
@@ -5318,8 +5328,8 @@ export class Manager {
         try {
             let entries = [];
             const nc = this.auth
-                ? await connect({ servers: this.servers ?? DEFAULT_SERVER, ...standaloneConnectOpts({ creds: await mintCreds(this.auth, newIdentity(), "provisioner"), /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 })
-                : await connect({ servers: this.servers ?? DEFAULT_SERVER, maxReconnectAttempts: 0 });
+                ? await this.dial({ ...standaloneConnectOpts({ creds: await mintCreds(this.auth, newIdentity(), "provisioner"), /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 })
+                : await this.dial({ maxReconnectAttempts: 0 });
             try {
                 const kvm = new Kvm(nc);
                 await ensureAuthorityStores(await jetstreamManager(nc), kvm, this.space);
@@ -6281,7 +6291,7 @@ export class Manager {
             return;
         const identity = newIdentity();
         const creds = await mintCreds(this.auth, identity, "provisioner");
-        const nc = await connect({ servers: this.servers ?? DEFAULT_SERVER, ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
+        const nc = await this.dial({ ...standaloneConnectOpts({ creds, /* not yet wired to a recorded transport */ tls: false }), maxReconnectAttempts: 0 });
         const slotRows = [];
         try {
             const jsm = await jetstreamManager(nc);