@piagent/platform 1.16.2 → 1.17.0

package/packages/piagent-webui/dist/client/index.html

@@ -7,7 +7,7 @@
     <meta name="csp-nonce" content="__PIAGENT_CSP_NONCE__" />
     <meta name="piagent-webui-mode" content="__PIAGENT_WEBUI_MODE__" />
     <title>Piagent WebUI</title>
-    <script type="module" crossorigin src="/assets/index-DJGByyfL.js"></script>
+    <script type="module" crossorigin src="/assets/index-BNQK7rHr.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Z91z6SlN.css">
   </head>
   <body>

package/packages/piagent-webui/gateway/git-head.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export type GitHead = { name: string; detached: boolean };
+
+const MAX_DEPTH = 40;
+
+// The branch a project folder stands on, read from the repository's HEAD file
+// rather than by running git: the catalog asks for every project each time the
+// dashboard refreshes, and a file read costs nothing. A linked worktree's
+// `.git` is a file naming its own git directory, which holds its own HEAD.
+// Null when the folder is not inside a repository or HEAD cannot be read.
+export function readGitHead(cwd: string): GitHead | null {
+  if (!cwd) return null;
+  let folder = path.resolve(cwd);
+  for (let depth = 0; depth < MAX_DEPTH; depth += 1) {
+    const dotGit = path.join(folder, ".git");
+    let stat: fs.Stats | null = null;
+    try { stat = fs.statSync(dotGit); } catch { /* keep walking up */ }
+    if (stat) return headAt(stat.isDirectory() ? dotGit : linkedGitDir(dotGit, folder));
+    const parent = path.dirname(folder);
+    if (parent === folder) return null;
+    folder = parent;
+  }
+  return null;
+}
+
+function linkedGitDir(dotGitFile: string, folder: string): string | null {
+  try {
+    const match = /^gitdir:\s*(.+?)\s*$/m.exec(fs.readFileSync(dotGitFile, "utf8").slice(0, 4096));
+    return match ? path.resolve(folder, match[1]) : null;
+  } catch { return null; }
+}
+
+function headAt(gitDir: string | null): GitHead | null {
+  if (!gitDir) return null;
+  let head: string;
+  try { head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").slice(0, 1024).trim(); } catch { return null; }
+  const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+  if (ref) return { name: ref[1], detached: false };
+  if (/^[0-9a-f]{40,64}$/i.test(head)) return { name: head.slice(0, 7), detached: true };
+  return null;
+}
+
+// One read per project folder while a catalog is built.
+export function gitHeadReader(): (cwd: string) => GitHead | null {
+  const seen = new Map<string, GitHead | null>();
+  return (cwd) => {
+    if (!seen.has(cwd)) seen.set(cwd, readGitHead(cwd));
+    return seen.get(cwd)!;
+  };
+}

package/packages/piagent-webui/gateway/session-catalog.ts

@@ -6,6 +6,7 @@ import { workflowCommandPattern } from "../../piagent-core/runtime/workflows/web
 import type { Catalog, SessionRow } from "../contracts/generated/session-catalog-v1.ts";
 import type { MetadataSnapshot, SessionMetadata } from "./session-metadata-store.ts";
 import { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
+import { gitHeadReader, type GitHead } from "./git-head.ts";
 
 export { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
 
@@ -105,7 +106,8 @@ function revision(key: Buffer, value: unknown): string {
 }
 
 function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undefined, metadataReason: string | null,
-  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection): SessionRow {
+  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection, gitHead?: GitHead | null): SessionRow {
+  const gitBranch = gitHead ? { name: display(gitHead.name, 200, "HEAD"), detached: gitHead.detached } : null;
   const projectLabel = display(info.cwd ? path.basename(info.cwd) : "", 120, "Unknown project");
   const projected = projectedSessionTitle(info);
   return {
@@ -123,6 +125,7 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
     unread: metadata?.unread ?? false,
     composerAvailable: metadata?.archived ? false : ownership?.composerAvailable ?? false,
     needsAttention: metadata?.archived ? false : ownership?.needsAttention ?? false,
+    ...(gitBranch ? { gitBranch } : {}),
     ...(sessionOptions?.managedHelpers ? {managedHelpers:{...sessionOptions.managedHelpers,
       active: ownership?.liveState === 'idle' ? 0 : ownership?.liveState === 'running' || ownership?.liveState === 'waiting-approval' ? sessionOptions.managedHelpers.active : null}} : {}),
     ...(sessionOptions?.managedThinkingLevels ? {managedThinkingLevels:sessionOptions.managedThinkingLevels} : {}),
@@ -138,6 +141,7 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
       : ownership?.owner ?? { kind: "none", ownerEpoch: null, gatewayInstanceRef: null, runtimeInstanceRef: null, continuity: "unknown" },
     sessionRevision: revision(key, [info.path, info.modified.toISOString(), info.messageCount, info.name ?? null, metadata?.revision ?? null,
       sessionOptions?.modelLabel ?? null, sessionOptions?.thinkingLevel ?? "unknown", sessionOptions?.managedHelpers, sessionOptions?.managedThinkingLevels, sessionOptions?.managedPermission ?? null, sessionOptions?.managedPlan, sessionOptions?.managedProcess,
+      gitBranch,
       metadata?.archived ? "archived" : ownership ? [ownership.state, ownership.liveState, ownership.owner.kind,
         ownership.owner.ownerEpoch, ownership.owner.runtimeInstanceRef, ownership.reasonCode] : "offline"]),
     reasonCode: metadata?.archived ? metadataReason : ownership?.reasonCode ?? metadataReason
@@ -151,16 +155,18 @@ export async function buildSessionCatalog(options: {
   readMetadata?(): MetadataSnapshot;
   readOwnership?(sessionRef: string): SessionOwnerProjection;
   readSessionOptions?(info: PiSessionInfo): SessionOptionProjection;
+  readGitHead?(cwd: string): GitHead | null;
   limit?: number;
 }): Promise<Catalog> {
   const limit = Math.max(1, Math.min(200, options.limit ?? 200));
   try {
     const found = (await options.listSessions()).filter(isUserConversationSession);
+    const readHead = options.readGitHead ?? gitHeadReader();
     const metadata = options.readMetadata?.() ?? { state: "ready", revision: null, sessions: new Map(), reasonCode: null };
     const sessions = found.map((info) => {
       const sessionRef = sessionRefForPath(options.key, info.path);
       return row(options.key, info, metadata.sessions.get(sessionRef), metadata.reasonCode, options.readOwnership?.(sessionRef),
-        options.readSessionOptions?.(info));
+        options.readSessionOptions?.(info), readHead(info.cwd));
     }).sort((left, right) => Number(right.pinned) - Number(left.pinned)
       || Date.parse(right.updatedAt) - Date.parse(left.updatedAt)).slice(0, limit);
     return {

package/schemas/piagent-webui/session-catalog-v1.schema.json

@@ -99,6 +99,9 @@
         "managedProcess": { "type": "object", "additionalProperties": false, "required": ["outcome", "verified", "reviewed", "blockingOpen"], "properties": {
           "outcome": { "enum": ["no_change", "interrupted", "disputed", "blocking_open", "unverified", "review_unavailable", "unreviewed", "clean"] },
           "verified": { "type": "boolean" }, "reviewed": { "type": "boolean" }, "blockingOpen": { "type": "integer", "minimum": 0, "maximum": 1000 }, "planSkipped": { "const": true } } },
+        "gitBranch": { "type": "object", "additionalProperties": false, "required": ["name", "detached"], "properties": {
+          "name": { "type": "string", "minLength": 1, "maxLength": 200, "pattern": "^[^\\u0000-\\u001F\\u007F]*$" },
+          "detached": { "type": "boolean" } } },
         "modelLabel": { "$ref": "common-v1.schema.json#/$defs/nullableDisplayText" },
         "thinkingLevel": { "enum": ["off", "minimal", "low", "medium", "high", "xhigh", "max", "unknown"] },
         "contextUsage": { "$ref": "#/$defs/contextUsage" },

package/scripts/dashboard-update-job.mjs

@@ -72,6 +72,9 @@ fs.writeSync(log, "\nRestarting the dashboard on the new release\n");
 // install sits under node_modules, where Node does not strip types itself.
 // --import takes a URL: a Windows path (C:\...) reads as a URL scheme.
 const loader = pathToFileURL(path.join(packageRoot, "scripts", "register-typescript-loader.mjs")).href;
+// The new dashboard checks for the next release itself: only the update step
+// runs without the check.
+const restartEnv = { ...process.env }; delete restartEnv.PIAGENT_NO_UPDATE_CHECK;
 const restart = spawnSync(process.execPath, ["--disable-warning=ExperimentalWarning", "--import", loader, dashboard, "restart", "--json"],
-  { stdio: ["ignore", "ignore", log], env, timeout: 3 * 60 * 1000 });
+  { stdio: ["ignore", "ignore", log], env: restartEnv, timeout: 3 * 60 * 1000 });
 finish("succeeded", { installed, ...(bindingChanged ? { bindingChanged } : {}), ...(restart.status === 0 ? {} : { reason: "dashboard-restart-failed" }) });

package/scripts/piagent-dashboard.mjs

@@ -154,6 +154,18 @@ async function waitForGatewayStopped(previous, timeoutMs = 8_000) {
   throw new Error("gateway-restart-stop-timeout\nThe previous Gateway did not stop; restart refused to reuse the old process.");
 }
 
+// An update job of an earlier release restarted the dashboard with update
+// checks switched off (it meant them for its own install step only): a
+// dashboard it starts checks for releases again.
+function serveEnvironment(home = os.homedir()) {
+  const env = { ...process.env };
+  try {
+    const job = JSON.parse(fs.readFileSync(path.join(home, ".pi", "piagent-update-job.json"), "utf8"));
+    if (job?.state === "running" && job.pid === process.ppid) delete env.PIAGENT_NO_UPDATE_CHECK;
+  } catch { /* no update running */ }
+  return env;
+}
+
 async function ensureStarted() {
   // After an update the Gateway still running is the earlier release, with
   // its pages loaded: it is replaced rather than reused.
@@ -174,7 +186,7 @@ async function ensureStarted() {
     fileURLToPath(import.meta.url),
     "serve",
     ...(agentDir ? ["--agent-dir", agentDir] : [])
-  ], { cwd: process.cwd(), env: { ...process.env,
+  ], { cwd: process.cwd(), env: { ...serveEnvironment(),
     PIAGENT_PINNED_TS_TRANSFORM_ROOT: path.join(effectiveAgentDir, "npm", "node_modules", "pi-mcp-adapter") },
     detached: true, stdio: "ignore" });
   let exit = null;