usebeeline 0.0.1 → 0.0.3

package/README.md

@@ -3,11 +3,11 @@
 Connect a supported coding-agent harness to Beeline:
 
 ```sh
-npx usebeeline connect
+npx usebeeline connect <PAIRING_CODE_FROM_THE_APP>
 ```
 
-The package also exposes a `beeline` bin alias. The connect command opens a
-short-lived browser approval, installs the signed current daemon bundle into
+The package also exposes a `beeline` bin alias. The connect command uses the
+short-lived code minted by the Beeline app, installs the signed current daemon bundle into
 the canonical `~/.local` layout, and starts the supervised user service.
 
 The wizard asks exactly for the harness, any required provider credential, the

package/dist/usebeeline.mjs

@@ -1264,18 +1264,18 @@ function validateTableBytes(numPoints, fpBytes) {
   if (bytes > TABLE_BYTES_MAX)
     throw new Error("invalid window size: table would need ~" + Math.ceil(bytes / 2 ** 20) + " MiB, max " + TABLE_BYTES_MAX / 2 ** 20 + " MiB");
 }
-function probeRandomBytes(randomBytes8, length) {
-  if (randomBytes8 === void 0)
+function probeRandomBytes(randomBytes7, length) {
+  if (randomBytes7 === void 0)
     return void 0;
-  afunction(randomBytes8, "randomBytes");
+  afunction(randomBytes7, "randomBytes");
   try {
-    const probe = randomBytes8(length);
+    const probe = randomBytes7(length);
     if (!isBytes2(probe) || probe.length !== length)
       return void 0;
   } catch {
     return void 0;
   }
-  return randomBytes8;
+  return randomBytes7;
 }
 function validateMSMPoints(points, c2) {
   aarray(points, "points");
@@ -1431,9 +1431,9 @@ var init_curve = __esm({
       baseCanBeBlinded;
       bits;
       // Parametrized with a given Point class (not individual point)
-      constructor(Point, randomBytes8) {
+      constructor(Point, randomBytes7) {
         validatePointCons(Point);
-        this.randomBytes = probeRandomBytes(randomBytes8, BLIND_BYTES);
+        this.randomBytes = probeRandomBytes(randomBytes7, BLIND_BYTES);
         this.Point = Point;
         this.BASE = Point.BASE;
         this.ZERO = Point.ZERO;
@@ -1666,7 +1666,7 @@ function weierstrass(params, extraOpts = {}) {
     randomBytes: "function"
   });
   const { endo, allowInfinityPoint } = extraOpts;
-  const randomBytes8 = extraOpts.randomBytes === void 0 ? randomBytes2 : extraOpts.randomBytes;
+  const randomBytes7 = extraOpts.randomBytes === void 0 ? randomBytes2 : extraOpts.randomBytes;
   if (endo) {
     if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
       throw new Error('invalid endo: expected "beta": bigint and "basises": array');
@@ -2078,7 +2078,7 @@ function weierstrass(params, extraOpts = {}) {
     }
   }
   const normalize3 = (points) => normalizeZ(Point, points);
-  const wnaf = new ScalarMultiplier(Point, randomBytes8);
+  const wnaf = new ScalarMultiplier(Point, randomBytes7);
   if (wnaf.bits >= 6)
     Point.BASE.precompute(6);
   Object.freeze(Point.prototype);
@@ -4102,7 +4102,7 @@ function ecdsa2(Point, hash, ecdsaOpts = {}) {
     bits2int_modN: "function"
   });
   ecdsaOpts = Object.assign({}, ecdsaOpts);
-  const randomBytes8 = ecdsaOpts.randomBytes || randomBytes3;
+  const randomBytes7 = ecdsaOpts.randomBytes || randomBytes3;
   const hmac2 = ecdsaOpts.hmac || ((key, msg) => hmac(hash, key, msg));
   const { Fp, Fn } = Point;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
@@ -4244,7 +4244,7 @@ function ecdsa2(Point, hash, ecdsaOpts = {}) {
       throw new Error("invalid private key");
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (extraEntropy != null && extraEntropy !== false) {
-      const e = extraEntropy === true ? randomBytes8(lengths.secretKey) : extraEntropy;
+      const e = extraEntropy === true ? randomBytes7(lengths.secretKey) : extraEntropy;
       seedArgs.push(abytes3(e, void 0, "extraEntropy"));
     }
     const seed = concatBytes3(...seedArgs);
@@ -11338,7 +11338,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes8, createHash: createHash16 } = __require("crypto");
+    var { randomBytes: randomBytes7, createHash: createHash15 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -11876,7 +11876,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes8(16).toString("base64");
+      const key = randomBytes7(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -12006,7 +12006,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash16("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash15("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -12375,7 +12375,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash16 } = __require("crypto");
+    var { createHash: createHash15 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -12682,7 +12682,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash16("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash15("sha1").update(key + GUID).digest("base64");
         const headers2 = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -22029,11 +22029,11 @@ function parseUpdateManifest(raw, platform) {
   }
   const bundle = entry;
   const file = typeof bundle.file === "string" ? bundle.file : "";
-  const sha2565 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
+  const sha2564 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
   if (!file || !/^[a-z0-9][a-z0-9._-]*$/i.test(file)) {
     throw new Error(`update manifest names an unusable bundle file: ${JSON.stringify(bundle.file)}`);
   }
-  if (!/^[0-9a-f]{64}$/.test(sha2565)) {
+  if (!/^[0-9a-f]{64}$/.test(sha2564)) {
     throw new Error(`update manifest carries no usable sha256 for ${platform}`);
   }
   const sourceCommit = typeof bundle.commit === "string" && bundle.commit ? bundle.commit : typeof manifest.sourceCommit === "string" ? manifest.sourceCommit : void 0;
@@ -22045,7 +22045,7 @@ function parseUpdateManifest(raw, platform) {
     bundles,
     bundle: {
       file,
-      sha256: sha2565,
+      sha256: sha2564,
       ...typeof bundle.bytes === "number" ? { bytes: bundle.bytes } : {},
       ...sourceCommit ? { commit: sourceCommit } : {},
       ...version ? { version } : {},
@@ -24397,10 +24397,10 @@ function parseArtifact(value) {
   const artifactId = token(input.artifactId);
   const revision = integer(input.revision, 1);
   const eventId = typeof input.eventId === "string" && HEX_64.test(input.eventId) ? input.eventId : void 0;
-  const sha2565 = typeof input.sha256 === "string" && SHA_256.test(input.sha256) ? input.sha256 : void 0;
-  if (!artifactId || revision === void 0 || !eventId || !sha2565)
+  const sha2564 = typeof input.sha256 === "string" && SHA_256.test(input.sha256) ? input.sha256 : void 0;
+  if (!artifactId || revision === void 0 || !eventId || !sha2564)
     return void 0;
-  return { artifactId, revision, eventId, sha256: sha2565 };
+  return { artifactId, revision, eventId, sha256: sha2564 };
 }
 function parseArtifacts(value) {
   if (!Array.isArray(value) || value.length === 0 || value.length > MAX_PERMISSION_LIST_ITEMS) {
@@ -30168,7 +30168,7 @@ function normalizeAttachmentReference(value) {
     return null;
   const thumbnailUrl = value.thumbnailUrl ? httpUrl2(value.thumbnailUrl) : void 0;
   const previewUrl = value.previewUrl ? httpUrl2(value.previewUrl) : void 0;
-  const sha2565 = value.sha256?.toLowerCase();
+  const sha2564 = value.sha256?.toLowerCase();
   const width = cleanSize(value.width ?? 0);
   const height = cleanSize(value.height ?? 0);
   return {
@@ -30177,7 +30177,7 @@ function normalizeAttachmentReference(value) {
     mimeType,
     size,
     ...previewUrl ? { previewUrl } : {},
-    ...sha2565 && /^[0-9a-f]{64}$/.test(sha2565) ? { sha256: sha2565 } : {},
+    ...sha2564 && /^[0-9a-f]{64}$/.test(sha2564) ? { sha256: sha2564 } : {},
     ...thumbnailUrl ? { thumbnailUrl } : {},
     ...value.width !== void 0 && width !== void 0 && width > 0 ? { width } : {},
     ...value.height !== void 0 && height !== void 0 && height > 0 ? { height } : {}
@@ -47718,6 +47718,13 @@ Deliver artifacts from this corner; there is no branch to land.`;
   }
   /** Human decision path retained for a named repository outside the Room binding. */
   async cornerOpenAudience(roomId, requesterPubkey) {
+    if (this.daemonApi) {
+      const authority = await this.daemonApi.execute("getRoomAuthority", {
+        roomId,
+        principalId: requesterPubkey
+      });
+      return authority.member && authority.principalKind === "human" ? [requesterPubkey] : [];
+    }
     const members = await listMembers(this.agentClientContext(), roomId);
     const candidates = members.filter((member2) => member2.pubkey === requesterPubkey || member2.role === "admin" || member2.role === "owner");
     const checked = await Promise.all(candidates.map(async (member2) => ({
@@ -47756,9 +47763,10 @@ Deliver artifacts from this corner; there is no branch to land.`;
           message: published.message
         };
       }
-      const permissionId = randomUUID5();
+      const permissionId = this.daemonApi ? createHash10("sha256").update(`corner-permission\0${input.roomId}\0${input.request.eventId}`).digest("hex") : randomUUID5();
       const repository2 = input.roomRepo ? this.repoId(input.roomRepo) : "repo-less";
-      const audience = await this.cornerOpenAudience(input.roomId, input.request.authorPubkey);
+      const principalId = input.request.delegation?.rootHumanPubkey ?? input.request.authorPubkey;
+      const audience = await this.cornerOpenAudience(input.roomId, principalId);
       if (audience.length === 0) {
         throw new AgentToolKnownFailure("approval_audience_unavailable", "No eligible human is available to decide this corner request.", true);
       }
@@ -47766,7 +47774,18 @@ Deliver artifacts from this corner; there is no branch to land.`;
       const requester = requesterAttribution?.handle ?? fallbackPersonName(input.request.authorPubkey);
       const agent = (await this.roomAuthorAttributions(input.roomId, [this.agentIdentity.publicKey])).get(this.agentIdentity.publicKey)?.name ?? fallbackAgentName(this.agentIdentity.publicKey);
       const message2 = `@${requester.replace(/^@/, "")} asked ${agent} to open a corner for: ` + input.objective;
-      const card = buildControlMessage("permission-request", input.roomId, this.agentIdentity, message2, [
+      const card = this.daemonApi ? await this.daemonApi.execute("postPermissionRequest", {
+        roomId: input.roomId,
+        principalId,
+        permissionId,
+        requestId: input.request.eventId,
+        scope: {
+          type: "operation.execute",
+          connectorId: input.tool,
+          target: repository2,
+          payloadDigest: createHash10("sha256").update(input.objective).digest("hex")
+        }
+      }) : buildControlMessage("permission-request", input.roomId, this.agentIdentity, message2, [
         ["t", WRITE_PERMISSION_REQUEST_TAG],
         ["permission", permissionId],
         ["request", input.request.eventId],
@@ -47779,7 +47798,8 @@ Deliver artifacts from this corner; there is no branch to land.`;
         ...this.delegatedReplyTags(input.request),
         ...audience.map((pubkey2) => ["p", pubkey2])
       ]);
-      await publishEvent2(card, this.agentIdentity);
+      if (!this.daemonApi)
+        await publishEvent2(card, this.agentIdentity);
       void this.finishCornerApproval({ ...input, permissionId, repository: repository2, audience }).catch((error) => console.error("[body] corner approval settlement failed:", error));
       return { request_id: permissionId, event_id: card.id, message: message2 };
     })();
@@ -47792,6 +47812,8 @@ Deliver artifacts from this corner; there is no branch to land.`;
    * the signed pending card already authored for this exact member request.
    */
   async publishedCornerApproval(input) {
+    if (this.daemonApi)
+      return void 0;
     const repository2 = input.roomRepo ? this.repoId(input.roomRepo) : "repo-less";
     const events = await this.agentRelay.queryEvents([
       {
@@ -47811,9 +47833,11 @@ Deliver artifacts from this corner; there is no branch to land.`;
     return { permissionId, eventId: event.id, message: event.content, repository: repository2, audience };
   }
   async finishCornerApproval(input) {
+    const principalId = input.request.delegation?.rootHumanPubkey ?? input.request.authorPubkey;
     let deciderPubkey;
     const decision = await this.waitForWritePermissionDecision(input.roomId, input.permissionId, input.request.eventId, input.repository, 10 * 6e4, {
       allowedResponders: new Set(input.audience),
+      principalId,
       captureDecider: (pubkey2) => {
         deciderPubkey = pubkey2;
       }
@@ -47823,44 +47847,61 @@ Deliver artifacts from this corner; there is no branch to land.`;
     if (decision === "allow") {
       try {
         const info = await this.openSubchannelForRequest(input.roomId, input.roomRepo, input.objective, input.request, { objective: input.objective, suppressOpenCard: true });
-        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, input.request.authorPubkey);
+        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, principalId);
         this.startCornerTaskOnce(info, input.objective, cornerOpenTaskPrompt(info.taskDescription, input.objective), {
           requestId: input.request.eventId,
           originalRequestId: input.request.eventId,
           cause: "corner-opening"
         });
       } catch (error) {
-        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "failed", `Corner approved by @${deciderHandle.replace(/^@/, "")}, but it could not start: ${this.safePermissionFailure(error)}`, void 0, deciderPubkey, input.request.authorPubkey);
+        await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, "failed", `Corner approved by @${deciderHandle.replace(/^@/, "")}, but it could not start: ${this.safePermissionFailure(error)}`, void 0, deciderPubkey, principalId);
       }
       return;
     }
-    await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, decision === "deny" ? "denied" : "expired", decision === "deny" ? `Corner denied by @${deciderHandle.replace(/^@/, "")}.` : "The corner request expired without a decision.", void 0, deciderPubkey, input.request.authorPubkey);
+    await this.postWritePermissionStatus(input.roomId, input.permissionId, input.request.eventId, input.tool, input.repository, decision === "deny" ? "denied" : "expired", decision === "deny" ? `Corner denied by @${deciderHandle.replace(/^@/, "")}.` : "The corner request expired without a decision.", void 0, deciderPubkey, principalId);
   }
   async requestEditCornerApproval(input) {
     const { tlcChannelId, turn, repository: repository2, tool, objective, namedTarget, pendingMessage } = input;
-    const permissionId = randomUUID5();
-    const audience = await this.cornerOpenAudience(tlcChannelId, turn.request.authorPubkey);
+    const permissionId = this.daemonApi ? createHash10("sha256").update(`edit-permission\0${tlcChannelId}\0${turn.request.eventId}`).digest("hex") : randomUUID5();
+    const principalId = turn.request.delegation?.rootHumanPubkey ?? turn.request.authorPubkey;
+    const audience = await this.cornerOpenAudience(tlcChannelId, principalId);
     if (audience.length === 0) {
       throw new AgentToolKnownFailure("approval_audience_unavailable", "No eligible human is available to decide this corner request.", true);
     }
-    const requesterAttribution = turn.request.delegation ? (await this.roomAuthorAttributions(tlcChannelId, [turn.request.authorPubkey])).get(turn.request.authorPubkey) : turn.request.authorAttribution;
-    const requester = requesterAttribution?.handle ?? fallbackPersonName(turn.request.authorPubkey);
-    await postControlMessage("permission-request", tlcChannelId, this.agentIdentity, `@${requester.replace(/^@/, "")} asked ${this.agentIdentity.name || "the agent"} to open a corner for: ${objective || pendingMessage}`, [
-      ["t", WRITE_PERMISSION_REQUEST_TAG],
-      ["permission", permissionId],
-      ["request", turn.request.eventId],
-      ["requester", turn.request.authorPubkey],
-      ["agent", this.agentIdentity.publicKey],
-      ...audience.map((pubkey2) => ["p", pubkey2]),
-      ["tool", tool],
-      ["repo", repository2],
-      ["objective", objective],
-      ["status", "pending"],
-      ...this.delegatedReplyTags(turn.request)
-    ]);
+    const requesterAttribution = turn.request.delegation ? (await this.roomAuthorAttributions(tlcChannelId, [principalId])).get(principalId) : turn.request.authorAttribution;
+    const requester = requesterAttribution?.handle ?? fallbackPersonName(principalId);
+    if (this.daemonApi) {
+      await this.daemonApi.execute("postPermissionRequest", {
+        roomId: tlcChannelId,
+        principalId,
+        permissionId,
+        requestId: turn.request.eventId,
+        scope: {
+          type: "operation.execute",
+          connectorId: tool,
+          target: repository2,
+          payloadDigest: createHash10("sha256").update(objective || pendingMessage).digest("hex")
+        }
+      });
+    } else {
+      await postControlMessage("permission-request", tlcChannelId, this.agentIdentity, `@${requester.replace(/^@/, "")} asked ${this.agentIdentity.name || "the agent"} to open a corner for: ${objective || pendingMessage}`, [
+        ["t", WRITE_PERMISSION_REQUEST_TAG],
+        ["permission", permissionId],
+        ["request", turn.request.eventId],
+        ["requester", turn.request.authorPubkey],
+        ["agent", this.agentIdentity.publicKey],
+        ...audience.map((pubkey2) => ["p", pubkey2]),
+        ["tool", tool],
+        ["repo", repository2],
+        ["objective", objective],
+        ["status", "pending"],
+        ...this.delegatedReplyTags(turn.request)
+      ]);
+    }
     let deciderPubkey;
     const decision = await this.waitForWritePermissionDecision(tlcChannelId, permissionId, turn.request.eventId, repository2, 10 * 6e4, {
       allowedResponders: new Set(audience),
+      principalId,
       captureDecider: (pubkey2) => {
         deciderPubkey = pubkey2;
       }
@@ -47876,7 +47917,7 @@ Deliver artifacts from this corner; there is no branch to land.`;
           suppressOpenCard: true
         }) : await this.openSubchannel(tlcChannelId, boundRepo, objective, { ...turn.request, content: objective }, { objective, suppressOpenCard: true });
         turn.transitionedToCorner = true;
-        await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, turn.request.authorPubkey).catch((statusError) => console.error("[body] failed to publish direct corner navigation:", statusError));
+        await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "allowed", `Corner approved by @${deciderHandle.replace(/^@/, "")} \u2014 view \u2192`, info.subchannelId, deciderPubkey, principalId).catch((statusError) => console.error("[body] failed to publish direct corner navigation:", statusError));
         this.startCornerTaskOnce(info, objective, cornerOpenTaskPrompt(info.taskDescription, objective), {
           requestId: turn.request.eventId,
           originalRequestId: turn.request.eventId,
@@ -47889,10 +47930,10 @@ Deliver artifacts from this corner; there is no branch to land.`;
       return;
     }
     if (decision === "deny") {
-      await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "denied", `Corner denied by @${deciderHandle.replace(/^@/, "")}.`, void 0, deciderPubkey, turn.request.authorPubkey);
+      await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "denied", `Corner denied by @${deciderHandle.replace(/^@/, "")}.`, void 0, deciderPubkey, principalId);
       return;
     }
-    await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "expired", `The edit request for ${repository2} expired. The Agent remains read-only.`, void 0, void 0, turn.request.authorPubkey);
+    await this.postWritePermissionStatus(tlcChannelId, permissionId, turn.request.eventId, tool, repository2, "expired", `The edit request for ${repository2} expired. The Agent remains read-only.`, void 0, void 0, principalId);
   }
   permissionToolLabel(permission) {
     const title = permission.toolCall?.title?.trim();
@@ -48203,6 +48244,26 @@ Deliver artifacts from this corner; there is no branch to land.`;
     return summarizeGitFailure(raw).replace(/https?:\/\/\S+/gi, "the configured remote").replace(/(?:[A-Za-z0-9._~+/=-]+):(?:[A-Za-z0-9._~+/=-]+)@/g, "[credentials]@").replace(/\s+/g, " ").trim().slice(0, 240) || "the repository could not be cloned or accessed";
   }
   postWritePermissionStatus(tlcChannelId, permissionId, requestId, tool, repository2, status, message2, subchannelId, deciderPubkey, requesterPubkey) {
+    if (this.daemonApi) {
+      const publishStatus = async () => {
+        if (requesterPubkey && (status === "allowed" || status === "failed" || status === "expired")) {
+          await this.daemonApi.execute("postPermissionExecution", {
+            roomId: tlcChannelId,
+            principalId: requesterPubkey,
+            permissionId,
+            status: status === "allowed" ? "succeeded" : "failed",
+            result: message2
+          });
+        }
+        await this.daemonApi.execute("postRoomMessage", {
+          roomId: tlcChannelId,
+          requestId,
+          text: message2,
+          presentation: "system"
+        });
+      };
+      return publishStatus();
+    }
     return postControlMessage("permission-status", tlcChannelId, this.agentIdentity, message2, [
       ["t", WRITE_PERMISSION_REQUEST_TAG],
       ["permission", permissionId],
@@ -48227,6 +48288,53 @@ Deliver artifacts from this corner; there is no branch to land.`;
    * pending decision until timeout.
    */
   async waitForWritePermissionDecision(tlcChannelId, permissionId, requestId, repository2, timeoutMs = 10 * 6e4, options = {}) {
+    if (this.daemonApi) {
+      if (!options.principalId)
+        throw new Error("monolith permission wait requires a principal");
+      const deadline2 = Date.now() + timeoutMs;
+      return new Promise((resolvePromise, rejectPromise) => {
+        let settled = false;
+        let polling = false;
+        const finish = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          clearInterval(backstop);
+          resolvePromise(result);
+        };
+        const pollOnce = async () => {
+          if (settled || polling)
+            return;
+          polling = true;
+          try {
+            const authority = await this.daemonApi.execute("getPermissionAuthority", {
+              roomId: tlcChannelId,
+              principalId: options.principalId,
+              permissionId
+            });
+            if (authority.status === "authorized")
+              finish("allow");
+            if (authority.status === "denied")
+              finish("deny");
+          } catch (error) {
+            if (!isTransientPermissionPollError(error)) {
+              settled = true;
+              clearTimeout(timer);
+              clearInterval(backstop);
+              rejectPromise(error);
+            }
+          } finally {
+            polling = false;
+          }
+        };
+        const timer = setTimeout(() => finish("timeout"), Math.max(0, deadline2 - Date.now()));
+        timer.unref?.();
+        const backstop = setInterval(() => void pollOnce(), WRITE_PERMISSION_BACKSTOP_POLL_MS);
+        backstop.unref?.();
+        void pollOnce();
+      });
+    }
     const startedAt = Math.floor(Date.now() / 1e3) - 1;
     const deadline = Date.now() + timeoutMs;
     const matchingDecision = async (event) => {
@@ -51176,6 +51284,55 @@ async function assertRuntimeStorageWritable(supervisorRoot, agentPubkey) {
     await rm7(probe, { force: true }).catch(() => void 0);
   }
 }
+async function stageMonolithAgentRuntime(input) {
+  const supervisorRoot = input.supervisorRoot ? resolve28(input.supervisorRoot) : defaultSupervisorRoot(input.env);
+  const baseUrl = new URL(input.monolithBaseUrl).origin;
+  if (baseUrl !== input.monolithBaseUrl || !/^https?:$/.test(new URL(baseUrl).protocol)) {
+    throw new Error("monolith base URL must be an HTTP or HTTPS origin");
+  }
+  if (!/^bde_[A-Za-z0-9_-]{43}$/.test(input.daemonExchangeToken)) {
+    throw new Error("daemon exchange token is invalid");
+  }
+  const configPath = resolve28(runtimeDirectory(supervisorRoot, input.agentIdentity.publicKey), "runtime.json");
+  if (await agentRuntimeExists(supervisorRoot, input.agentIdentity.publicKey)) {
+    const existing = await readRuntimeRecord(configPath);
+    const transport = existing.transport;
+    const sameRuntime = existing.communityId === input.workspaceId && existing.pairedBy === input.pairedBy && existing.agent.publicKey === input.agentIdentity.publicKey && existing.agent.secretKeyHex === Buffer.from(input.agentIdentity.secretKey).toString("hex") && existing.body.publicKey === input.bodyIdentity.publicKey && transport?.kind === "monolith" && transport.baseUrl === baseUrl && ("daemonToken" in transport || transport.exchangeToken === input.daemonExchangeToken);
+    if (!sameRuntime) {
+      throw new Error(`agent identity ${input.agentIdentity.publicKey} already has another runtime`);
+    }
+    return { runtime: existing, configPath };
+  }
+  await assertRuntimeStorageWritable(supervisorRoot, input.agentIdentity.publicKey);
+  const runtime = {
+    version: 2,
+    communityId: input.workspaceId,
+    pairedBy: input.pairedBy,
+    agent: storeIdentity(input.agentIdentity, DEFAULT_AGENT_IDENTITY_NAME),
+    body: storeIdentity(input.bodyIdentity, DEFAULT_BODY_IDENTITY_NAME),
+    rooms: [],
+    supervisorRoot,
+    // Required only by legacy records. Monolith runtimes never construct a
+    // relay client, so retaining the server origin here cannot route traffic.
+    relayBaseUrl: baseUrl,
+    transport: {
+      kind: "monolith",
+      baseUrl,
+      exchangeToken: input.daemonExchangeToken
+    },
+    ...input.llmEnvFile ? { llmEnvFile: input.llmEnvFile } : {},
+    accessPolicy: DEFAULT_ACCESS_POLICY,
+    ...input.modelSelection?.model || input.modelSelection?.effort ? { modelSelection: input.modelSelection } : {},
+    agentKind: input.agentKind,
+    agentCommand: input.agentCommand,
+    agentArgs: [...input.agentArgs ?? []],
+    agentBinary: input.agentBinary,
+    mcpBinary: input.mcpBinary,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const writtenPath = await writeRuntimeRecord(runtime);
+  return { runtime, configPath: writtenPath };
+}
 async function writeRuntimePointer(gitCommonDir, agentPubkey, targetConfigPath) {
   const directory = runtimeDirectory(gitCommonDir, agentPubkey);
   const path = resolve28(directory, "runtime.json");
@@ -55703,33 +55860,49 @@ async function pairOneAgent(input) {
     throw error;
   }
 }
-async function completeDevicePairing(grant) {
-  const selectedAgent = await selectPairAgentCommand({
+async function completeDevicePairing(grant, options = {}) {
+  const selectedAgent = options.selectedAgent ?? await selectPairAgentCommand({
     explicitKind: grant.harness,
     env: process.env,
     cwd: process.cwd(),
     interactive: true,
     confirmInstall: async () => true
   });
-  const result = await pairOneAgent({
-    code: grant.pairingCode,
-    selectedAgent,
-    agentIdentity: identityFromKey(grant.agentSecretKey, grant.agentName),
-    bodyIdentity: identityFromKey(grant.bodySecretKey, DEFAULT_BODY_IDENTITY_NAME),
-    cwd: process.cwd(),
-    repo: null,
-    progressLabel: "Connecting agent\u2026",
-    progressDone: (pid) => `Connected (pid ${pid}).`,
+  const localConfig = options.localConfig ?? loadBodyConfig({
+    workspaceRoot: process.cwd(),
     ...grant.llmEnvFile ? { llmEnvFile: grant.llmEnvFile } : {},
-    access: "creator",
+    agent: selectedAgent
+  });
+  await (options.validateSelection ?? validateModelSelection)(selectedAgent, localConfig.agentEnv, {
+    model: grant.model
+  });
+  const agentIdentity = identityFromKey(grant.agentSecretKey, grant.agentName);
+  const staged = await stageMonolithAgentRuntime({
+    workspaceId: grant.workspaceId,
+    pairedBy: grant.pairedBy,
+    monolithBaseUrl: grant.monolithBaseUrl,
+    daemonExchangeToken: grant.daemonExchangeToken,
+    ...grant.llmEnvFile ? { llmEnvFile: grant.llmEnvFile } : {},
+    agentBinary: localConfig.agentBinary,
+    agentKind: selectedAgent.kind,
+    agentCommand: selectedAgent.command,
+    agentArgs: selectedAgent.args,
     modelSelection: { model: grant.model },
-    agentProfile: { displayName: grant.agentName, personality: grant.soul },
-    interactiveUi: false
+    mcpBinary: localConfig.mcpBinary,
+    agentIdentity,
+    bodyIdentity: identityFromKey(grant.bodySecretKey, DEFAULT_BODY_IDENTITY_NAME),
+    ...options.supervisorRoot ? { supervisorRoot: options.supervisorRoot } : {}
   });
-  if (result.pairing.communityId !== grant.workspaceId) {
-    throw new Error("approved Workspace did not match the pairing grant");
+  const activated = await activateDaemonTransport(staged.configPath, options.fetchImpl);
+  if (!activated)
+    throw new Error("monolith daemon transport activation failed");
+  let pid;
+  try {
+    pid = await (options.launch ?? (async (configPath, publicKey) => process.platform === "linux" && process.env.BEELINE_SYSTEMD_USER !== "0" ? installAgentService(publicKey) : launchRuntimeDaemon(configPath)))(staged.configPath, agentIdentity.publicKey);
+  } catch (error) {
+    throw new Error(`agent ${agentIdentity.publicKey} is connected, but its daemon did not start: ${error instanceof Error ? error.message : String(error)}. Run \`beeline start --agent ${agentIdentity.publicKey}\`.`, { cause: error });
   }
-  return result;
+  return { runtime: activated.runtime, configPath: staged.configPath, pid };
 }
 function printPairResult(result) {
   console.log(`[buzz] paired agent ${import_picocolors3.default.bold(result.pairing.agent.displayName)}`);
@@ -55857,7 +56030,6 @@ async function runPairCommand(args, llmEnvFile, agentPrivateKey) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn12 } from "node:child_process";
-import { createHash as createHash15, randomBytes as randomBytes7 } from "node:crypto";
 import { chmod as chmod7, mkdir as mkdir18, readFile as readFile13, unlink as unlink5, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname16, resolve as resolve37 } from "node:path";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
@@ -55999,9 +56171,6 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
     soul: soul.trim()
   };
 }
-function sha2564(value) {
-  return createHash15("sha256").update(value).digest("hex");
-}
 async function jsonRequest(url, body, fetchImpl) {
   const response = await fetchImpl(url, {
     method: "POST",
@@ -56015,41 +56184,15 @@ async function jsonRequest(url, body, fetchImpl) {
   }
   return response.json();
 }
-async function openBrowser(url) {
-  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  await new Promise((resolveOpen, rejectOpen) => {
-    const child = spawn12(command, args, { detached: true, stdio: "ignore" });
-    child.once("error", rejectOpen);
-    child.once("spawn", () => {
-      child.unref();
-      resolveOpen();
-    });
-  });
-}
-async function pollDeviceGrant(input) {
-  const deadline = Date.now() + input.start.expires_in * 1e3;
-  while (Date.now() < deadline) {
-    const response = await input.fetchImpl(`${input.baseUrl}/auth/device/token`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        device_code: input.start.device_code,
-        code_verifier: input.verifier
-      }),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (response.status === 428) {
-      await new Promise((resolveWait) => setTimeout(resolveWait, input.start.interval * 1e3));
-      continue;
-    }
-    if (!response.ok) {
-      const detail = await response.json().catch(() => ({}));
-      throw new Error(detail.message ?? detail.error ?? `authorization failed (HTTP ${response.status})`);
-    }
-    return response.json();
-  }
-  throw new Error("browser authorization expired; run `npx usebeeline connect` again");
+function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
+  return jsonRequest(`${baseUrl}/auth/agent/connect`, {
+    pairing_code: pairingCode.trim().toUpperCase(),
+    harness: selection.harness,
+    ...selection.provider ? { provider: selection.provider } : {},
+    model: selection.model,
+    soul: selection.soul,
+    agent_name: selection.name
+  }, fetchImpl);
 }
 async function installCurrentRelease(fetchImpl) {
   const manifestUrl = resolveManifestUrl(process.env);
@@ -56136,34 +56279,23 @@ async function brassSpinner(message2, action) {
     throw error;
   }
 }
-async function runConnectCommand(options = {}) {
+async function runConnectCommand(code, options = {}) {
   if (!stdin4.isTTY || !stdout5.isTTY) {
     throw new Error("`usebeeline connect` needs an interactive terminal");
   }
   intro(brass("Beeline connect"));
+  const pairingCode = code?.trim() || await clackPrompts.text({
+    message: brass("Pairing code from the app"),
+    validate: (value) => value.trim() ? void 0 : "Pairing code is required"
+  });
   const selection = await collectConnectWizard();
   const fetchImpl = options.fetchImpl ?? fetch;
   const baseUrl = (process.env.BEELINE_AUTH_URL ?? "https://server.usebeeline.app").replace(/\/$/, "");
-  const verifier = randomBytes7(32).toString("base64url");
-  const start = await brassSpinner("Preparing secure sign-in\u2026", () => jsonRequest(`${baseUrl}/auth/device/connect`, {
-    harness: selection.harness,
-    ...selection.provider ? { provider: selection.provider } : {},
-    model: selection.model,
-    soul: selection.soul,
-    agent_name: selection.name,
-    code_challenge: sha2564(verifier)
-  }, fetchImpl));
-  try {
-    await openBrowser(start.verification_uri_complete);
-  } catch {
-    console.log(`Open this link to connect: ${start.verification_uri_complete}`);
-  }
-  const grant = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => pollDeviceGrant({ baseUrl, start, verifier, fetchImpl }));
+  const grant = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl));
   const installedBinary = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl));
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
   const grantPath = resolve37(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
-    pairingCode: grant.pairing_code,
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
     agentName: grant.agent_name,
@@ -56172,6 +56304,9 @@ async function runConnectCommand(options = {}) {
     soul: grant.soul,
     workspaceId: grant.workspace_id,
     workspaceName: grant.workspace_name,
+    pairedBy: grant.paired_by,
+    monolithBaseUrl: baseUrl,
+    daemonExchangeToken: grant.daemon_exchange_token,
     ...llmEnvFile ? { llmEnvFile } : {}
   });
   await brassSpinner("Starting your agent\u2026", () => runInstalledFinish(installedBinary, grantPath));
@@ -56184,7 +56319,13 @@ function isDevicePairingGrant(value) {
   if (!value || typeof value !== "object")
     return false;
   const grant = value;
-  return typeof grant.pairingCode === "string" && typeof grant.agentSecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.agentSecretKey) && typeof grant.bodySecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.bodySecretKey) && typeof grant.agentName === "string" && CONNECT_HARNESSES.includes(grant.harness) && typeof grant.model === "string" && typeof grant.soul === "string" && typeof grant.workspaceId === "string" && typeof grant.workspaceName === "string";
+  let monolithOrigin = "";
+  try {
+    monolithOrigin = new URL(grant.monolithBaseUrl ?? "").origin;
+  } catch {
+    return false;
+  }
+  return typeof grant.agentSecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.agentSecretKey) && typeof grant.bodySecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.bodySecretKey) && typeof grant.agentName === "string" && CONNECT_HARNESSES.includes(grant.harness) && typeof grant.model === "string" && typeof grant.soul === "string" && typeof grant.workspaceId === "string" && typeof grant.workspaceName === "string" && typeof grant.pairedBy === "string" && /^[0-9a-f]{64}$/.test(grant.pairedBy) && typeof grant.monolithBaseUrl === "string" && grant.monolithBaseUrl === monolithOrigin && /^https?:$/.test(new URL(monolithOrigin).protocol) && typeof grant.daemonExchangeToken === "string" && /^bde_[A-Za-z0-9_-]{43}$/.test(grant.daemonExchangeToken);
 }
 async function runConnectFinishCommand(path) {
   if (!path)
@@ -57200,7 +57341,7 @@ ${import_picocolors6.default.dim("Usage:")}
   beeline archive <subchannel-uuid>         Archive subchannel
   beeline pair <BUZZ-XXXX-XXXX> [options]   Pair an agent (optionally to this repo)
                                             and start its durable daemon
-  beeline connect                           Install and connect an agent through the browser
+  beeline connect [BUZZ-XXXX-XXXX]          Install and connect an app-authorized agent
   beeline start [agent-pubkey]              Start \u2014 or RESTART when already running,
                                             stopping cleanly after in-flight work \u2014
                                             this repo's (or, outside a repo, this
@@ -57590,7 +57731,7 @@ async function main2() {
     return;
   }
   if (command === "connect") {
-    await runConnectCommand();
+    await runConnectCommand(args[1]);
     return;
   }
   if (command === "connect-finish") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "repository": {
     "type": "git",