@sjawhar/pi-legion-envoy 1.66.1 → 1.68.0

package/dist/legion.js

@@ -16142,7 +16142,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "1.66.1",
+  version: "1.68.0",
   type: "module",
   omp: {
     extensions: [
@@ -16155,7 +16155,7 @@ var package_default = {
   },
   legion: {
     daemonApiVersion: 8,
-    goDaemonApiVersion: 3
+    goDaemonApiVersion: 4
   },
   repository: {
     type: "git",
@@ -31238,42 +31238,47 @@ function onEnvoyRoleRegained(listener) {
 }
 
 // src/legion/controller-session.ts
-function createControllerSession(persistedTranscript, checkSubagentSession, rerunReadyAfterRegain, pluginVersion) {
+function typescriptControllerDaemon(rerunReadyAfterRegain, pluginVersion) {
+  let daemon;
+  const client = () => {
+    daemon ??= createLegionDaemonClient(requiredEnvironment(process.env, "LEGION_DAEMON_URL"));
+    return daemon;
+  };
+  return {
+    claim: async ({ sessionID, capability, ompSessionFile, context }) => {
+      const daemon2 = client();
+      const { project } = await daemon2.state();
+      const token = controllerToken(project);
+      await claimEnvoyRole(sessionID, token, "setInterval" in context ? context : undefined);
+      const ready = {
+        secret: capability,
+        sessionId: sessionID,
+        ...ompSessionFile === undefined ? {} : { ompSessionFile },
+        pluginVersion
+      };
+      await daemon2.controllerReady(ready);
+      onEnvoyRoleRegained(async (role, reason) => {
+        if (role !== token)
+          return;
+        await rerunReadyAfterRegain("controller/ready", role, reason, () => daemon2.controllerReady(ready));
+      });
+      return () => daemon2.grant({ sessionId: sessionID, secret: capability });
+    }
+  };
+}
+function createControllerSession(persistedTranscript, checkSubagentSession, daemon) {
   let controllerSessionID;
   let controllerCapability;
-  let controllerDaemon;
-  const controllerDaemonClient = () => {
-    controllerDaemon ??= createLegionDaemonClient(requiredEnvironment(process.env, "LEGION_DAEMON_URL"));
-    return controllerDaemon;
-  };
+  let mintControllerGrant;
   let controllerTranscript;
   const claim = async (context) => {
     const sessionID = context.sessionManager.getSessionId();
-    const daemon = controllerDaemonClient();
-    const secret = controllerCapability ?? requiredControllerCapability(process.env);
-    controllerCapability = secret;
-    const { project } = await daemon.state();
-    const token = controllerToken(project);
-    await claimEnvoyRole(sessionID, token, "setInterval" in context ? context : undefined);
+    const capability = controllerCapability ?? requiredControllerCapability(process.env);
+    controllerCapability = capability;
     const ompSessionFile = classifySession(process.env).kind === "controller" ? (await persistedTranscript(context)).sessionFile : undefined;
-    await daemon.controllerReady({
-      secret,
-      sessionId: sessionID,
-      ...ompSessionFile === undefined ? {} : { ompSessionFile },
-      pluginVersion
-    });
+    mintControllerGrant = await daemon().claim({ sessionID, capability, ompSessionFile, context });
     controllerSessionID = sessionID;
     controllerTranscript = ompSessionFile;
-    onEnvoyRoleRegained(async (role, reason) => {
-      if (role !== token)
-        return;
-      await rerunReadyAfterRegain("controller/ready", role, reason, () => daemon.controllerReady({
-        secret,
-        sessionId: sessionID,
-        ...controllerTranscript === undefined ? {} : { ompSessionFile: controllerTranscript },
-        pluginVersion
-      }));
-    });
   };
   const handleSessionStart = async (context) => {
     if (classifySession(process.env).kind !== "controller")
@@ -31297,13 +31302,12 @@ function createControllerSession(persistedTranscript, checkSubagentSession, reru
       context.ui.notify(`legion: re-claiming the controller for this session failed (${messageFor(error48)}). Until a re-claim succeeds, controller wakes and merges will not reach this session and its shell commands run without a Legion grant, so legion gh is unavailable.`, "warning");
     }
   };
-  const isClaimedSession = (sessionID) => controllerSessionID === sessionID && controllerCapability !== undefined;
+  const isClaimedSession = (sessionID) => controllerSessionID === sessionID && mintControllerGrant !== undefined;
   const mintGrant = async (sessionID) => {
-    if (controllerSessionID !== sessionID || controllerCapability === undefined) {
+    if (controllerSessionID !== sessionID || mintControllerGrant === undefined) {
       throw new Error("Controller session is not registered; cannot mint its grant");
     }
-    const secret = controllerCapability;
-    return controllerDaemonClient().grant({ sessionId: sessionID, secret });
+    return mintControllerGrant();
   };
   return { claim, handleSessionStart, reclaimAfterSessionChange, isClaimedSession, mintGrant };
 }
@@ -31436,11 +31440,18 @@ var legionGoAdmission = exports_external.strictObject({
   active: exports_external.array(nonEmptyString2),
   waiting: exports_external.array(nonEmptyString2)
 });
+var legionGoControllerLocator = exports_external.strictObject({
+  runtime: exports_external.enum(["tmux", "kubernetes"]),
+  external: exports_external.literal(true),
+  sessionId: nonEmptyString2,
+  registeredAt: timestamp
+});
 var LegionGoStateResponse = exports_external.strictObject({
   daemon: goDaemonInfo,
   admission: legionGoAdmission,
   issues: exports_external.record(exports_external.string(), legionGoIssue),
-  pendingStatusWrites: exports_external.array(legionGoPendingStatusWrite)
+  pendingStatusWrites: exports_external.array(legionGoPendingStatusWrite),
+  controllerLocator: legionGoControllerLocator.optional()
 });
 var LegionGoRegisterResponse = exports_external.strictObject({
   claimToken: nonEmptyString2,
@@ -31450,6 +31461,15 @@ var LegionGoRegisterResponse = exports_external.strictObject({
   generation: exports_external.number().int().positive(),
   secret: nonEmptyString2
 });
+var LegionGoControllerRegisterResponse = exports_external.strictObject({
+  claimToken: nonEmptyString2,
+  role: exports_external.literal("controller"),
+  generation: exports_external.number().int().positive(),
+  secret: nonEmptyString2
+});
+var LegionGoControllerSecretResponse = exports_external.strictObject({
+  secret: nonEmptyString2
+});
 var LegionGoErrorResponse = exports_external.union([
   exports_external.strictObject({ error: nonEmptyString2 }),
   exports_external.strictObject({ code: nonEmptyString2, error: nonEmptyString2 })
@@ -31504,6 +31524,10 @@ var LegionGoGrantRequest = exports_external.strictObject({
   tree: nonEmptyString2,
   issue: nonEmptyString2
 });
+var LegionGoControllerGrantRequest = exports_external.strictObject({
+  sessionId: nonEmptyString2,
+  secret: nonEmptyString2
+});
 var LegionGoGrantCredentialRequest = exports_external.strictObject({
   grantId: nonEmptyString2
 });
@@ -31624,9 +31648,11 @@ function createLegionGoDaemonClient(baseUrl, fetchFn = fetch) {
   return {
     state: () => read("GET", "/legion/v1/state", LegionGoStateResponse),
     register: (input) => read("POST", "/legion/v1/claims/register", LegionGoRegisterResponse, input),
+    registerController: (input) => read("POST", "/legion/v1/claims/register", LegionGoControllerRegisterResponse, input),
     ready: (input) => acknowledge("/legion/v1/claims/ready", input),
     exit: (input) => acknowledge("/legion/v1/claims/exit", input),
     grant: (input) => post("/legion/v1/grants", LegionGoGrantRequest, LegionGoGrantResponse, input),
+    controllerGrant: (input) => post("/legion/v1/grants", LegionGoControllerGrantRequest, LegionGoGrantResponse, input),
     githubToken: (input) => post("/legion/v1/gh-token", LegionGoGrantCredentialRequest, LegionGoGitHubTokenResponse, input),
     gitCredential: (input) => post("/legion/v1/git-credential", LegionGoGrantCredentialRequest, LegionGoGitCredentialResponse, input),
     provisioningCredential: (input) => post("/legion/v1/provisioning-credential", LegionGoGrantCredentialRequest, LegionGoGitHubTokenResponse, input),
@@ -31726,13 +31752,31 @@ async function callGoReadyWithRetry(label, call) {
     }
   }
 }
+function goControllerDaemon(daemon, transcript) {
+  return {
+    claim: async ({ sessionID, capability, context }) => {
+      const { sessionFile, agentId } = await transcript(context);
+      const client = daemon();
+      const registration = await client.registerController({
+        bootToken: capability,
+        sessionId: sessionID,
+        ompSessionFile: sessionFile,
+        agentId,
+        pluginContract: package_default.legion.goDaemonApiVersion
+      }).catch((error48) => {
+        if (error48 instanceof LegionGoDaemonApiError) {
+          console.error(`[legion] claims/register for the controller failed (${error48.status}): ${error48.detail}`);
+        }
+        throw error48;
+      });
+      await claimEnvoyRole(sessionID, registration.claimToken, "setInterval" in context ? context : undefined);
+      return () => client.controllerGrant({ sessionId: sessionID, secret: registration.secret });
+    }
+  };
+}
 async function bootstrapGoClaim(context, state) {
-  const classification = classifySession(process.env);
-  if (classification.kind === "not-legion")
+  if (classifySession(process.env).kind === "not-legion")
     return;
-  if (classification.kind === "controller") {
-    throw new Error("LEGION_DAEMON_API=go names the Go daemon, which launches no controller session");
-  }
   const sessionID = context.sessionManager.getSessionId();
   const capability = state.capability();
   if (capability !== undefined && capability.sessionID !== sessionID)
@@ -32626,11 +32670,13 @@ function legionExtension(pi) {
       console.error(`[legion] ${endpoint} after role ${role} was ${reason} failed; the daemon's held work stays undelivered until the next regain or boot: ${messageFor(error48)}`);
     }
   };
+  const typescriptController = typescriptControllerDaemon(rerunReadyAfterRegain, package_default.version);
+  const goController = goControllerDaemon(goRoleDaemon, persistedTranscript);
   const controllerSession = createControllerSession(async (context) => {
     const persisted = await persistedTranscript(context);
     recordBootstrappedSession(persisted.sessionFile);
     return persisted;
-  }, checkSubagentSession, rerunReadyAfterRegain, package_default.version);
+  }, checkSubagentSession, () => process.env.LEGION_DAEMON_API === "go" ? goController : typescriptController);
   const reclaimArchitect = async () => {
     if (capability === undefined || capability.kind !== "root-architect") {
       throw new Error("Legion root architect is not available for reclamation");
@@ -32828,6 +32874,10 @@ function legionExtension(pi) {
       return;
     phaseStall = restorePhaseStall(context.sessionManager.getBranch?.() ?? []);
     if (process.env.LEGION_DAEMON_API === "go") {
+      if (classifySession(process.env).kind === "controller") {
+        await controllerSession.handleSessionStart(context);
+        return;
+      }
       await bootstrapGoClaim(context, {
         capability: () => capability,
         setCapability: (next) => {

package/dist/skills/legion-controller/SKILL.md

@@ -59,23 +59,26 @@ command run `/legion-claim-controller` again.
 This handshake lets the daemon redeliver held controller work. It does not turn the controller
 into a state holder: daemon state and the Dispatch project remain authoritative.
 
-### Started by the operator (runtime: kubernetes)
-
-When the daemon runs inside a Kubernetes cluster it cannot open a terminal anywhere, so nobody
-launched your pane: the operator ran `legion controller start --config controller.yaml
-[--daemon-url <port-forward>]` on their own machine, and you are that foreground OMP session.
-The command fetched a fresh controller secret from the daemon with the operator's token, wrote it
-to a 0600 file under `LEGION_STATE_DIR` (`~/.local/state/legion/<project>-controller` by default)
-beside the `gh` shim and the `legion` launcher, and started you with `LEGION_CONTROLLER=1` and
-the same environment a tmux controller pane carries — so the extension claims the role and calls
-`/controller/ready` exactly as under tmux, and nothing changes in how you handle wakes. The
-daemon records you as `controllerLocator: {runtime: "kubernetes", external: true, sessionId,
-registeredAt}` and reads your liveness from the Envoy role registry (the holder of
+### Started by the operator
+
+When the daemon cannot open a terminal for you — the TypeScript daemon under `runtime: kubernetes`,
+and the Go daemon under either runtime, since it launches no controller — nobody launched your
+pane: the operator ran `legion controller start --config controller.yaml [--daemon-url <url>]` on
+their own machine, and you are that foreground OMP session. The command fetched a fresh controller
+secret from the daemon with the operator's token, wrote it to a 0600 file under `LEGION_STATE_DIR`
+(`~/.local/state/legion/<project>-controller` by default) beside the `gh` shim and the `legion`
+launcher, and started you with `LEGION_CONTROLLER=1` and the same environment a tmux controller pane
+carries, so nothing changes in how you handle wakes. Under the TypeScript daemon the extension
+claims the role and calls `/controller/ready` exactly as under tmux; under the Go daemon
+(`LEGION_DAEMON_API=go` in your environment) it registers on `/legion/v1/claims/register` with the
+secret, then claims the role. The daemon records you as `controllerLocator: {runtime, external:
+true, sessionId, registeredAt}`, `runtime` being the daemon's own (`kubernetes`, or `tmux` under the
+Go daemon). The TypeScript daemon reads your liveness from the Envoy role registry (the holder of
 `legion-<project>-controller` and its `last_seen`), not from a pane: keep the session running.
 Exiting it leaves the project without a controller until the operator runs the command again —
-the daemon logs `controller not registered; run legion controller start` once per boot-timeout
-interval and launches nothing itself. `legion state` and `legion status <KEY> <status>` work here
-over `LEGION_DAEMON_URL` (the port-forward). A second `legion controller start` replaces you: it
+the TypeScript daemon logs `controller not registered; run legion controller start` once per
+boot-timeout interval and launches nothing itself. `legion state` and `legion status <KEY>
+<status>` work here over `LEGION_DAEMON_URL`. A second `legion controller start` replaces you: it
 mints a new secret, so your grants stop working and the role moves to the new session.
 
 ## Deployment instructions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "1.66.1",
+  "version": "1.68.0",
   "type": "module",
   "omp": {
     "extensions": [
@@ -13,7 +13,7 @@
   },
   "legion": {
     "daemonApiVersion": 8,
-    "goDaemonApiVersion": 3
+    "goDaemonApiVersion": 4
   },
   "repository": {
     "type": "git",