@piagent/platform 1.3.1 → 1.4.1

package/packages/piagent-webui/gateway/session-inspection-registry.ts

@@ -0,0 +1,239 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+import { readContextTelemetry } from "../../piagent-core/extensions/context-engine.js";
+import { activeSessionTask } from "../../piagent-core/extensions/task-state.js";
+import { runtimeConnectionDefinitions, runtimeProtectedPaths } from "../../piagent-core/runtime/inspection/project-runtime-inspection.ts";
+import { setRuntimeMcpEnabled } from "../../piagent-core/runtime/inspection/mcp-control.ts";
+import { webUiModelRef } from "../../piagent-core/runtime/inspection/webui-snapshot.ts";
+import { redactSensitiveText } from "../../piagent-core/security/sensitive-data.js";
+import { piApprovalBroker } from "../../piagent-core/runtime/inspection/approval-broker.ts";
+import { CoreInspectionProvider } from "../server/core-inspection-provider.ts";
+import { ReadModelNotFound, type WebUiReadModelProvider } from "../server/read-model-provider.ts";
+import { projectRefForCwd, sessionRefForPath, type PiSessionInfo } from "./session-catalog.ts";
+import { nativeProjectPickerAvailable } from "./native-project-picker.ts";
+import type { McpAuthBroker } from "./mcp-auth-broker.ts";
+
+type PiHost = {
+  SessionManager: {
+    listAll(): Promise<PiSessionInfo[]>;
+    open(file: string): {
+      getBranch(): unknown[];
+      buildSessionContext(): { model: { provider: string; modelId: string } | null; thinkingLevel: string; messages: unknown[] };
+    };
+  };
+  calculateContextTokens(usage: unknown): number;
+  estimateTokens(message: unknown): number;
+  getLatestCompactionEntry(entries: unknown[]): unknown | null;
+};
+
+type ModelRuntime = {
+  getModel(provider: string, modelId: string): Record<string, unknown> | undefined;
+  getAvailableSnapshot(): readonly Record<string, unknown>[];
+};
+
+type ProjectSource = { list(): Array<{ projectRef: string; placeRef: string; label: string }> };
+
+const CACHE_LIMIT = 32;
+const PUBLIC_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:@~-]{0,159}$/;
+const EMPTY_REPLAY = {
+  state: "current" as const,
+  events: [],
+  nextCursor: "inspection-start",
+  latestCursor: "inspection-start",
+  reasonCode: null
+};
+
+function inspectionRuntimeRef(gatewayInstanceRef: string, sessionRef: string): string {
+  return `runtime.${createHash("sha256").update(`${gatewayInstanceRef}\0${sessionRef}`).digest("hex")}`;
+}
+
+function safeRead<T>(read: () => T, fallback: T): T {
+  try { return read(); } catch { return fallback; }
+}
+
+function safeName(value: unknown): string {
+  return redactSensitiveText(String(value ?? "")).text.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120)
+    || "Unnamed connection";
+}
+
+function safeModelId(value: unknown): string | null {
+  if (typeof value !== "string" || !PUBLIC_MODEL_ID.test(value)) return null;
+  return redactSensitiveText(value).redacted ? null : value;
+}
+
+function persistedContextUsage(host: PiHost, entries: unknown[], messages: unknown[], model: Record<string, unknown> | undefined) {
+  const contextWindow = Number(model?.contextWindow);
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return undefined;
+  const latestCompaction = host.getLatestCompactionEntry(entries);
+  if (latestCompaction) {
+    const boundary = entries.lastIndexOf(latestCompaction);
+    let hasPostCompactionUsage = false;
+    for (let index = entries.length - 1; index > boundary; index -= 1) {
+      const entry = entries[index] as { type?: unknown; message?: { role?: unknown; stopReason?: unknown; usage?: unknown } } | undefined;
+      const message = entry?.type === "message" ? entry.message : undefined;
+      if (message?.role === "assistant" && message.usage && message.stopReason !== "aborted" && message.stopReason !== "error"
+        && host.calculateContextTokens(message.usage) > 0) {
+        hasPostCompactionUsage = true;
+        break;
+      }
+    }
+    if (!hasPostCompactionUsage) return { tokens: null, contextWindow, percent: null };
+  }
+  let lastUsageIndex = -1, tokens = 0;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index] as { role?: unknown; stopReason?: unknown; usage?: unknown } | undefined;
+    if (message?.role !== "assistant" || !message.usage || message.stopReason === "aborted" || message.stopReason === "error") continue;
+    const measured = host.calculateContextTokens(message.usage);
+    if (measured > 0) { tokens = measured; lastUsageIndex = index; break; }
+  }
+  for (let index = lastUsageIndex + 1; index < messages.length; index += 1) tokens += host.estimateTokens(messages[index]);
+  if (!Number.isFinite(tokens) || tokens < 0) return undefined;
+  return { tokens, contextWindow, percent: tokens / contextWindow * 100 };
+}
+
+export class SessionInspectionRegistry {
+  readonly #gatewayInstanceRef: string;
+  readonly #host: PiHost;
+  readonly #key: Buffer;
+  readonly #packageRoot: string;
+  readonly #models?: ModelRuntime;
+  readonly #projects?: ProjectSource;
+  readonly #mcpAuth?: McpAuthBroker;
+  readonly #providers = new Map<string, { modifiedAt: string; provider: CoreInspectionProvider }>();
+
+  constructor(options: { gatewayInstanceRef: string; host: PiHost; key: Buffer; packageRoot: string; models?: ModelRuntime; projects?: ProjectSource;
+    mcpAuth?: McpAuthBroker }) {
+    this.#gatewayInstanceRef = options.gatewayInstanceRef;
+    this.#host = options.host;
+    this.#key = options.key;
+    this.#packageRoot = options.packageRoot;
+    this.#models = options.models;
+    this.#projects = options.projects;
+    this.#mcpAuth = options.mcpAuth;
+  }
+
+  #connectionRef(server: { scope: string; origin: string; name: string }): string {
+    return `mcp.${createHash("sha256").update(`${server.scope}\0${server.origin}\0${server.name}`).digest("hex")}`;
+  }
+
+  async #sessionInfo(sessionRef: string): Promise<PiSessionInfo> {
+    const sessions = await this.#host.SessionManager.listAll();
+    const found = sessions.filter((candidate) => sessionRefForPath(this.#key, candidate.path) === sessionRef);
+    if (found.length !== 1) throw new ReadModelNotFound();
+    return found[0]!;
+  }
+
+  async connections(sessionRef: string): Promise<unknown> {
+    const info = await this.#sessionInfo(sessionRef);
+    const definitions = safeRead(() => runtimeConnectionDefinitions(info.cwd), { servers: [], unreadableLayerCount: 1 });
+    const servers = await Promise.all(definitions.servers.slice(0, 100).map(async (server) => {
+      const auth = await this.#mcpAuth?.describe(info.cwd, server.name) ?? { oauthSupported: false as const, authState: "unavailable" as const };
+      return { connectionRef: this.#connectionRef(server), name: safeName(server.name), kind: "mcp" as const, scope: server.scope,
+        origin: safeName(server.origin), transport: typeof server.entry.url === "string" ? "http" as const
+          : typeof server.entry.command === "string" ? "stdio" as const : "unknown" as const,
+        state: server.entry.enabled === false ? "disabled" as const : auth.authState === "connected" ? "connected" as const : "configured" as const,
+        requiresApproval: server.requiresApproval, oauthSupported: auth.oauthSupported, authState: auth.authState,
+        toggleSupported: !server.origin.startsWith("import:") };
+    }));
+    return {
+      schemaVersion: 1,
+      version: "piagent-session-connections-v1",
+      generatedAt: new Date().toISOString(),
+      sessionRef,
+      state: definitions.unreadableLayerCount ? "degraded" : "ready",
+      summary: { configured: servers.length, connected: null, approvalRequired: servers.filter((server) => server.requiresApproval).length },
+      connections: servers,
+      truncated: servers.length >= 100,
+      reasonCode: definitions.unreadableLayerCount ? "one-or-more-connection-layers-unreadable" : null
+    };
+  }
+
+  async executeConnectionCommand(input: unknown): Promise<unknown> {
+    if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("mcp-command-invalid");
+    const command = input as Record<string, unknown>, keys = Object.keys(command);
+    if (!keys.every((key) => ["action", "sessionRef", "connectionRef"].includes(key)) || keys.length !== 3
+      || !["mcp.enable", "mcp.disable", "mcp.oauth"].includes(String(command.action))
+      || typeof command.sessionRef !== "string" || typeof command.connectionRef !== "string") throw new Error("mcp-command-invalid");
+    const info = await this.#sessionInfo(command.sessionRef), definitions = safeRead(() => runtimeConnectionDefinitions(info.cwd), { servers: [], unreadableLayerCount: 1 });
+    const matches = definitions.servers.filter((server) => this.#connectionRef(server) === command.connectionRef);
+    if (matches.length !== 1) throw new Error("mcp-connection-not-found");
+    const server = matches[0]!;
+    if (command.action === "mcp.oauth") {
+      if (!this.#mcpAuth) throw new Error("mcp-oauth-unavailable");
+      return await this.#mcpAuth.start({ sessionRef: command.sessionRef, connectionRef: command.connectionRef, cwd: info.cwd, name: server.name });
+    }
+    setRuntimeMcpEnabled({ projectPath: info.cwd, name: server.name, scope: server.scope, enabled: command.action === "mcp.enable" });
+    return await this.connections(command.sessionRef);
+  }
+
+  async creationOptions(): Promise<unknown> {
+    const sessions = await this.#host.SessionManager.listAll();
+    const projects = new Map<string, { projectRef: string; placeRef: string; label: string }>();
+    for (const info of sessions) {
+      if (!info.cwd) continue;
+      const projectRef = projectRefForCwd(this.#key, info.cwd);
+      if (!projects.has(projectRef)) projects.set(projectRef, { projectRef, placeRef: projectRef,
+        label: safeName(path.basename(info.cwd) || "Project") });
+    }
+    for (const project of safeRead(() => this.#projects?.list() ?? [], [])) {
+      if (!projects.has(project.projectRef)) projects.set(project.projectRef, project);
+    }
+    const models = (this.#models?.getAvailableSnapshot() ?? []).slice(0, 300).flatMap((value) => {
+      const provider = safeModelId(value.provider);
+      const modelId = safeModelId(value.id);
+      if (!provider || !modelId || typeof value.reasoning !== "boolean") return [];
+      const mapping = value.thinkingLevelMap && typeof value.thinkingLevelMap === "object"
+        ? value.thinkingLevelMap as Record<string, unknown> : {};
+      const thinkingLevels = value.reasoning ? ["off", "minimal", "low", "medium", "high", "xhigh", "max"]
+        .filter((level) => mapping[level] !== null && !(["xhigh", "max"].includes(level) && mapping[level] === undefined)) : ["off"];
+      return [{ modelRef: webUiModelRef(provider, modelId), provider, modelId, displayName: safeName(value.name ?? modelId),
+        reasoning: value.reasoning, thinkingLevels }];
+    });
+    return { schemaVersion: 1, version: "piagent-session-creation-options-v1", generatedAt: new Date().toISOString(),
+      projects: [...projects.values()].slice(0, 200), models,
+      projectImport: nativeProjectPickerAvailable() ? { status: "available", reasonCode: null }
+        : { status: "unavailable", reasonCode: "native-project-picker-unavailable" },
+      reasonCode: projects.size ? null : "no-known-project" };
+  }
+
+  async provider(sessionRef: string): Promise<WebUiReadModelProvider> {
+    const info = await this.#sessionInfo(sessionRef);
+    const modifiedAt = info.modified.toISOString();
+    const cached = this.#providers.get(sessionRef);
+    if (cached?.modifiedAt === modifiedAt) return cached.provider;
+
+    let manager: ReturnType<PiHost["SessionManager"]["open"]>;
+    try { manager = this.#host.SessionManager.open(info.path); }
+    catch { throw new ReadModelNotFound(); }
+    const context = safeRead(() => manager.buildSessionContext(), { model: null, thinkingLevel: "unknown", messages: [] });
+    const model = context.model ? this.#models?.getModel(context.model.provider, context.model.modelId) : undefined;
+    const entries = safeRead(() => manager.getBranch(), []);
+    const contextUsage = safeRead(() => persistedContextUsage(this.#host, entries, context.messages, model), undefined);
+    const eventStore = {
+      retention: () => ({ eventRetentionCount: 0, eventRetentionSeconds: 0 }),
+      currentCursor: () => null,
+      resyncRequired: () => false,
+      replay: () => EMPTY_REPLAY
+    };
+    const provider = new CoreInspectionProvider({
+      cwd: info.cwd,
+      sessionId: info.id,
+      runtimeInstanceId: inspectionRuntimeRef(this.#gatewayInstanceRef, sessionRef),
+      eventStore,
+      task: () => safeRead(() => activeSessionTask(info.cwd, info.id), undefined),
+      activityEvents: () => safeRead(() => readContextTelemetry(info.cwd, { limit: 5_000 }), []),
+      sessionEntries: () => entries,
+      protectedPaths: () => runtimeProtectedPaths(this.#packageRoot, info.cwd),
+      contextUsage: () => contextUsage,
+      model: () => model,
+      thinkingLevel: () => context.thinkingLevel,
+      approvalProjection: () => piApprovalBroker.projection(info.cwd, info.id),
+      approvalDetail: (approvalRef) => piApprovalBroker.detail(info.cwd, info.id, approvalRef)
+    });
+    this.#providers.delete(sessionRef);
+    this.#providers.set(sessionRef, { modifiedAt, provider });
+    while (this.#providers.size > CACHE_LIMIT) this.#providers.delete(this.#providers.keys().next().value as string);
+    return provider;
+  }
+}

package/packages/piagent-webui/gateway/session-lease-store.ts

@@ -0,0 +1 @@
+export * from "../ownership/session-lease-store.ts";

package/packages/piagent-webui/gateway/session-metadata-store.ts

@@ -0,0 +1,152 @@
+import { createHmac } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+import { redactSensitiveText } from "../../piagent-core/security/sensitive-data.js";
+
+const FILE_LIMIT = 4 * 1024 * 1024;
+const RECORD_LIMIT = 8 * 1024;
+const ENTRY_LIMIT = 10_000;
+const REF = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,159}$/;
+
+export type SessionMetadata = {
+  pinned: boolean;
+  archived: boolean;
+  unread: boolean;
+  projectGroup: string | null;
+  revision: string;
+};
+
+type MetadataRecord = {
+  version: "piagent-session-metadata-v1";
+  sequence: number;
+  recordedAt: string;
+  sessionRef: string;
+  previousRevision: string | null;
+  pinned: boolean;
+  archived: boolean;
+  unread: boolean;
+  projectGroup: string | null;
+};
+
+export type MetadataSnapshot = {
+  state: "ready" | "unavailable";
+  revision: string | null;
+  sessions: ReadonlyMap<string, SessionMetadata>;
+  reasonCode: string | null;
+};
+
+function digest(key: Buffer, namespace: string, value: unknown): string {
+  return `${namespace}_${createHmac("sha256", key).update(JSON.stringify(value)).digest("hex")}`;
+}
+
+function exactTimestamp(value: unknown): value is string {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)
+    && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+
+function safeGroup(value: unknown): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== "string") throw new Error("session-metadata-group-invalid");
+  const text = redactSensitiveText(value).text.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+  if (!text || text.length > 120) throw new Error("session-metadata-group-invalid");
+  return text;
+}
+
+function validRecord(value: unknown): value is MetadataRecord {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value as Partial<MetadataRecord>;
+  return Object.keys(record).every((key) => ["version", "sequence", "recordedAt", "sessionRef", "previousRevision",
+    "pinned", "archived", "unread", "projectGroup"].includes(key))
+    && record.version === "piagent-session-metadata-v1"
+    && Number.isSafeInteger(record.sequence) && Number(record.sequence) > 0
+    && exactTimestamp(record.recordedAt) && typeof record.sessionRef === "string" && REF.test(record.sessionRef)
+    && (record.previousRevision === null || typeof record.previousRevision === "string" && REF.test(record.previousRevision))
+    && typeof record.pinned === "boolean" && typeof record.archived === "boolean" && typeof record.unread === "boolean"
+    && (record.projectGroup === null || typeof record.projectGroup === "string" && record.projectGroup.length > 0
+      && record.projectGroup.length <= 120 && !/[\u0000-\u001f\u007f]/.test(record.projectGroup));
+}
+
+export class SessionMetadataStore {
+  readonly directory: string;
+  readonly file: string;
+  readonly #key: Buffer;
+
+  constructor(root: string, key: Buffer) {
+    this.directory = path.join(root, "sessions");
+    this.file = path.join(this.directory, "index.jsonl");
+    this.#key = key;
+    fs.mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(this.directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+      || (typeof process.getuid === "function" && stat.uid !== process.getuid())) throw new Error("session-metadata-root-invalid");
+    fs.chmodSync(this.directory, 0o700);
+  }
+
+  #readRecords(): MetadataRecord[] {
+    let stat: fs.Stats;
+    try { stat = fs.lstatSync(this.file); }
+    catch { return []; }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > FILE_LIMIT) throw new Error("session-metadata-file-invalid");
+    const descriptor = fs.openSync(this.file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+      const opened = fs.fstatSync(descriptor);
+      if (opened.dev !== stat.dev || opened.ino !== stat.ino || opened.size !== stat.size) throw new Error("session-metadata-file-race");
+      const text = fs.readFileSync(descriptor, "utf8");
+      const lines = text ? text.split("\n") : [];
+      if (lines.at(-1) === "") lines.pop();
+      if (lines.length > ENTRY_LIMIT) throw new Error("session-metadata-entry-limit");
+      return lines.map((line, index) => {
+        if (!line || Buffer.byteLength(line) > RECORD_LIMIT) throw new Error("session-metadata-record-limit");
+        let value: unknown;
+        try { value = JSON.parse(line); } catch { throw new Error("session-metadata-record-invalid"); }
+        if (!validRecord(value) || value.sequence !== index + 1) throw new Error("session-metadata-record-invalid");
+        return value;
+      });
+    } finally { fs.closeSync(descriptor); }
+  }
+
+  read(): MetadataSnapshot {
+    try {
+      const records = this.#readRecords();
+      const sessions = new Map<string, SessionMetadata>();
+      for (const record of records) {
+        const prior = sessions.get(record.sessionRef);
+        if (record.previousRevision !== (prior?.revision ?? null)) throw new Error("session-metadata-chain-invalid");
+        sessions.set(record.sessionRef, {
+          pinned: record.pinned, archived: record.archived, unread: record.unread, projectGroup: record.projectGroup,
+          revision: digest(this.#key, "metadata-revision", record)
+        });
+      }
+      return { state: "ready", revision: digest(this.#key, "metadata-store", records), sessions, reasonCode: null };
+    } catch {
+      return { state: "unavailable", revision: null, sessions: new Map(), reasonCode: "metadata-overlay-unavailable" };
+    }
+  }
+
+  update(sessionRef: string, expectedRevision: string | null, patch: Partial<Pick<SessionMetadata, "pinned" | "archived" | "unread" | "projectGroup">>, now = new Date()): SessionMetadata {
+    if (!REF.test(sessionRef)) throw new Error("session-metadata-ref-invalid");
+    const snapshot = this.read();
+    if (snapshot.state !== "ready") throw new Error(snapshot.reasonCode ?? "session-metadata-unavailable");
+    const current = snapshot.sessions.get(sessionRef);
+    if ((current?.revision ?? null) !== expectedRevision) throw new Error("session-metadata-stale-revision");
+    if (!Number.isFinite(now.getTime())) throw new Error("session-metadata-time-invalid");
+    const record: MetadataRecord = {
+      version: "piagent-session-metadata-v1", sequence: this.#readRecords().length + 1, recordedAt: now.toISOString(), sessionRef,
+      previousRevision: current?.revision ?? null, pinned: patch.pinned ?? current?.pinned ?? false,
+      archived: patch.archived ?? current?.archived ?? false, unread: patch.unread ?? current?.unread ?? false,
+      projectGroup: "projectGroup" in patch ? safeGroup(patch.projectGroup) : current?.projectGroup ?? null
+    };
+    const body = Buffer.from(`${JSON.stringify(record)}\n`);
+    if (body.length > RECORD_LIMIT) throw new Error("session-metadata-record-limit");
+    let stat: fs.Stats | null = null;
+    try { stat = fs.lstatSync(this.file); } catch { /* first record */ }
+    if (stat && (!stat.isFile() || stat.isSymbolicLink() || stat.size + body.length > FILE_LIMIT)) throw new Error("session-metadata-file-invalid");
+    const descriptor = fs.openSync(this.file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT
+      | (fs.constants.O_NOFOLLOW ?? 0), 0o600);
+    try { fs.writeFileSync(descriptor, body); fs.fsyncSync(descriptor); }
+    finally { fs.closeSync(descriptor); }
+    fs.chmodSync(this.file, 0o600);
+    return this.read().sessions.get(sessionRef)!;
+  }
+}