@volter-ai-dev/supercode-ui 0.1.70 → 0.1.72

package/source-inventory.d.ts

@@ -0,0 +1,240 @@
+export type SourceSection =
+  "profiles" | "channels" | "routes" | "triggers" | "skills" | "memory";
+export interface InventoryPage<T> {
+  status: "ready" | "loading" | "error" | "unavailable";
+  items: T[];
+  total: number;
+  error?: string;
+}
+export interface ProfileModel {
+  key: string;
+  name: string;
+  harness: string;
+  kind: string;
+  isDefault: boolean;
+  routes: number | null;
+  sessions: number | null;
+  model: string | null;
+}
+export interface ChannelModel {
+  key: string;
+  name: string;
+  harness: string;
+  kind: string;
+  account: string | null;
+  enabled: boolean | null;
+  configured: boolean | null;
+  connection: string;
+  sessions: number | null;
+}
+export interface RouteModel {
+  key: string;
+  harness: string;
+  target: string;
+  profileKey: string;
+  specificity: number | null;
+  isDefault: boolean;
+  match: Record<string, string>;
+}
+export interface TriggerModel {
+  key: string;
+  name: string;
+  harness: string;
+  kind: string;
+  route: string;
+  events: string[];
+  profile: string | null;
+  profileKey: string | null;
+  action: string | null;
+  session: string | null;
+  destination: string | null;
+  enabled: boolean | null;
+  authenticated: boolean | null;
+  description: string;
+}
+export interface SkillModel {
+  key: string;
+  name: string;
+  harness: string;
+  scope: string;
+  description: string;
+  version: string | null;
+  enabled: boolean | null;
+}
+export interface MemoryDocumentModel {
+  key: string;
+  name: string;
+  harness: string;
+  scope: string;
+  profile: string | null;
+  size: number | null;
+  updatedAt: string | null;
+  preview: string;
+  truncated: boolean;
+}
+export interface MemoryMatchModel {
+  key: string;
+  name: string;
+  harness: string;
+  scope: string;
+  profile: string | null;
+  line: number | null;
+  excerpt: string;
+}
+export interface MemorySearchResult {
+  total: number;
+  matches: MemoryMatchModel[];
+}
+export interface SourceInventory {
+  source: string;
+  profiles: InventoryPage<ProfileModel>;
+  channels: InventoryPage<ChannelModel>;
+  routes: InventoryPage<RouteModel>;
+  triggers: InventoryPage<TriggerModel>;
+  skills: InventoryPage<SkillModel>;
+  memory: InventoryPage<MemoryDocumentModel>;
+}
+export interface ApprovalModel {
+  key: string;
+  id: string;
+  harness: string;
+  kind: string;
+  status: string;
+  subject: string;
+  session: string | null;
+  runtime: string | null;
+  ageMs: number | null;
+  options: { id: string; label: string }[];
+}
+export interface ApprovalResult {
+  key: string;
+  optionId: string;
+  resolved: boolean;
+}
+export interface AdapterModel {
+  name: string;
+  state: string;
+  failures: number | null;
+  retryAt: string | null;
+}
+export interface RuntimeModel {
+  source: string;
+  status: "ready" | "unavailable";
+  observedAt: string | null;
+  activeTurns: number | null;
+  leases: number | null;
+  queuedMessages: number | null;
+  pendingRequests: number | null;
+  adapters: AdapterModel[];
+}
+export interface ProfileListProps {
+  profiles?: ProfileModel[];
+  onOpen?(key: string, opener: HTMLButtonElement): void;
+}
+export interface ProfileDetailsProps {
+  profile: ProfileModel;
+}
+export interface ChannelListProps {
+  channels?: ChannelModel[];
+}
+export interface RouteListProps {
+  routes?: RouteModel[];
+  profiles?: ProfileModel[];
+  onOpenProfile?: ProfileListProps["onOpen"];
+}
+export interface TriggerListProps {
+  triggers?: TriggerModel[];
+  profiles?: ProfileModel[];
+  onOpenProfile?: ProfileListProps["onOpen"];
+}
+export interface SkillListProps {
+  skills?: SkillModel[];
+  onOpen?: ProfileListProps["onOpen"];
+}
+export interface SkillDetailsProps {
+  skill: SkillModel;
+}
+export interface MemoryBrowserProps {
+  documents?: MemoryDocumentModel[];
+  onSearch?(query: string): Promise<MemorySearchResult>;
+}
+export interface SourceInspectorProps {
+  inventory: SourceInventory;
+  initialSection?: SourceSection;
+  section?: SourceSection;
+  selectedKey?: string | null;
+  onNavigate?(section: SourceSection, key: string | null): void;
+  onSearchMemory?: MemoryBrowserProps["onSearch"];
+}
+export interface ApprovalDetailsProps {
+  approval: ApprovalModel;
+  onResolve?(key: string, optionId: string): Promise<ApprovalResult>;
+}
+export interface ApprovalInboxProps {
+  approvals?: ApprovalModel[];
+  status?: "ready" | "loading" | "error";
+  onResolve?: ApprovalDetailsProps["onResolve"];
+}
+export interface AdapterStatusProps {
+  adapters?: AdapterModel[];
+}
+export interface OrchestrationOverviewProps {
+  model: RuntimeModel;
+}
+export const SOURCE_SECTIONS: SourceSection[];
+export function projectSourceInventory(
+  reads?: unknown,
+  options?: { sourceKey?: string; limit?: number },
+): SourceInventory;
+export function projectMemoryMatches(
+  read: unknown,
+  options?: { sourceKey?: string; limit?: number },
+): MemorySearchResult;
+export function projectApprovals(
+  read: unknown,
+  options?: { sourceKey?: string },
+): ApprovalModel[];
+export function createApprovalHost(options: {
+  client: {
+    listApprovals(query: any): Promise<unknown>;
+    resolveApproval(
+      id: string,
+      request: { option_id: string },
+    ): Promise<{ id: string; option_id: string; resolved: boolean }>;
+  };
+  harness: string;
+  session: string;
+  sourceKey?: string;
+  allowResolve?: boolean;
+}): {
+  list(): Promise<ApprovalModel[]>;
+  resolve(key: string, optionId: string): Promise<ApprovalResult>;
+};
+export function projectRuntimeState(
+  state: unknown,
+  options?: { sourceKey?: string },
+): RuntimeModel;
+export interface SourceInventoryHost {
+  inventory(sourceKey: string): Promise<SourceInventory>;
+  searchMemory(sourceKey: string, query: string): Promise<MemorySearchResult>;
+}
+/** Trusted host: configure native roots here; never accept them from browser requests. */
+export function createSourceInventoryHost(options: {
+  client: {
+    listProfiles(query: any): Promise<unknown>;
+    listChannels(query: any): Promise<unknown>;
+    listRoutes(query: any): Promise<unknown>;
+    listTriggers(query: any): Promise<unknown>;
+    listSkills(query: any): Promise<unknown>;
+    showMemory(harness: any, query: any): Promise<unknown>;
+    searchMemory(harness: any, query: string, request: any): Promise<unknown>;
+  };
+  sources: {
+    key: string;
+    harness: string;
+    homes?: Record<string, string>;
+    profile?: string;
+    home?: string;
+    cwd?: string;
+  }[];
+}): SourceInventoryHost;

package/source-inventory.mjs

@@ -0,0 +1,367 @@
+/** Bounded allowlisted projections. Native paths, credentials and queued prompts stay host-side. */
+const rows = (value) => (Array.isArray(value) ? value : []);
+const text = (value, max = 2000) =>
+  typeof value === "string"
+    ? value.length > max
+      ? `${value.slice(0, max - 1)}…`
+      : value
+    : "";
+const count = (value) =>
+  Number.isSafeInteger(value) && value >= 0 ? value : null;
+const key = (...parts) =>
+  parts.map((part) => encodeURIComponent(String(part ?? ""))).join(":");
+const flag = (value) => (typeof value === "boolean" ? value : null);
+const opaque = (value) => {
+  let hash = 14695981039346656037n;
+  for (const character of String(value || ""))
+    hash = BigInt.asUintN(
+      64,
+      (hash ^ BigInt(character.codePointAt(0))) * 1099511628211n,
+    );
+  return hash.toString(36);
+};
+export const SOURCE_SECTIONS = [
+  "profiles",
+  "channels",
+  "routes",
+  "triggers",
+  "skills",
+  "memory",
+];
+export function projectSourceInventory(
+  reads = {},
+  { sourceKey = "source", limit = 100 } = {},
+) {
+  limit = Number.isSafeInteger(limit) ? Math.min(500, Math.max(1, limit)) : 100;
+  const result = { source: sourceKey };
+  for (const section of SOURCE_SECTIONS) {
+    const read = reads[section];
+    const native = rows(
+      section === "skills"
+        ? read
+        : read?.[section === "memory" ? "documents" : section],
+    );
+    const project = {
+      profiles: (r) => ({
+        key: key(sourceKey, r.harness, r.name),
+        name: text(r.name, 200),
+        harness: text(r.harness, 100),
+        kind: text(r.kind, 100),
+        isDefault: r.default === true,
+        routes: count(r.routes),
+        sessions: count(r.sessions),
+        model: text(r.model, 200) || null,
+      }),
+      channels: (r) => ({
+        key: key(sourceKey, r.harness, r.name),
+        name: text(r.name, 200),
+        harness: text(r.harness, 100),
+        kind: text(r.kind, 100),
+        account: text(r.account, 200) || null,
+        enabled: flag(r.enabled),
+        configured: flag(r.configured),
+        connection: text(r.status, 100) || "unknown",
+        sessions: count(r.sessions),
+      }),
+      routes: (r, index) => ({
+        key: key(sourceKey, r.harness, index),
+        harness: text(r.harness, 100),
+        target: text(r.target, 200),
+        profileKey: key(sourceKey, r.harness, r.target),
+        specificity: Number.isFinite(r.specificity) ? r.specificity : null,
+        isDefault: r.default === true,
+        match: Object.fromEntries(
+          [
+            "platform",
+            "account",
+            "guild",
+            "team",
+            "chat_id",
+            "peer_kind",
+            "thread_id",
+            "roles",
+          ].flatMap((name) =>
+            r.match?.[name] == null
+              ? []
+              : [
+                  [
+                    name,
+                    name === "roles"
+                      ? rows(r.match.roles)
+                          .slice(0, 30)
+                          .map((v) => text(v, 200))
+                          .join(", ")
+                      : text(r.match[name], 200),
+                  ],
+                ],
+          ),
+        ),
+      }),
+      triggers: (r) => ({
+        key: key(sourceKey, r.harness, r.name),
+        name: text(r.name, 200),
+        harness: text(r.harness, 100),
+        kind: text(r.kind, 100),
+        route: text(r.route, 500),
+        events: rows(r.events)
+          .slice(0, 30)
+          .map((v) => text(v, 200)),
+        profile: text(r.target?.profile, 200) || null,
+        profileKey: r.target?.profile
+          ? key(sourceKey, r.harness, r.target.profile)
+          : null,
+        action: text(r.target?.action, 200) || null,
+        session: text(r.target?.session_key, 300) || null,
+        destination: text(r.deliver?.target, 300) || null,
+        enabled: flag(r.enabled),
+        authenticated: flag(r.authenticated),
+        description: text(r.description),
+      }),
+      skills: (r) => ({
+        key: key(sourceKey, r.harness, r.scope, r.name, opaque(r.location)),
+        name: text(r.name, 200),
+        harness: text(r.harness, 100),
+        scope: text(r.scope, 100),
+        description: text(r.description),
+        version: text(r.version, 100) || null,
+        enabled: flag(r.enabled),
+      }),
+      memory: (r) => ({
+        key: key(sourceKey, r.harness, r.scope, r.profile, r.name),
+        name: text(r.name, 300),
+        harness: text(r.harness, 100),
+        scope: text(r.scope, 100),
+        profile: text(r.profile, 200) || null,
+        size: count(r.size),
+        updatedAt: text(r.updated_at, 100) || null,
+        preview: rows(r.preview)
+          .slice(0, 30)
+          .map((v) => text(v, 500))
+          .join("\n"),
+        truncated:
+          r.truncated === true ||
+          rows(r.preview).length > 30 ||
+          rows(r.preview).some((v) => typeof v === "string" && v.length > 500),
+      }),
+    }[section];
+    result[section] = {
+      status: read === undefined ? "unavailable" : "ready",
+      items: native.slice(0, limit).map(project),
+      total: native.length,
+    };
+  }
+  return result;
+}
+export function projectMemoryMatches(
+  read,
+  { sourceKey = "source", limit = 100 } = {},
+) {
+  const matches = rows(read?.matches);
+  const bound = Number.isSafeInteger(limit)
+    ? Math.min(500, Math.max(1, limit))
+    : 100;
+  return {
+    total: matches.length,
+    matches: matches
+      .slice(0, bound)
+      .map((r, index) => ({
+        key: key(sourceKey, "match", index),
+        name: text(r.name, 300),
+        harness: text(r.harness, 100),
+        scope: text(r.scope, 100),
+        profile: text(r.profile, 200) || null,
+        line: count(r.line),
+        excerpt: text(r.excerpt, 1000),
+      })),
+  };
+}
+export function createSourceInventoryHost({ client, sources }) {
+  const byKey = new Map(sources.map((s) => [s.key, s]));
+  if (byKey.size !== sources.length)
+    throw new Error("Source keys must be unique");
+  const get = (key) => {
+    const source = byKey.get(key);
+    if (!source) throw new Error("Unknown source");
+    return source;
+  };
+  return {
+    async inventory(sourceKey) {
+      const source = get(sourceKey);
+      const q = { harness: source.harness, homes: source.homes };
+      const calls = {
+        profiles: () => client.listProfiles(q),
+        channels: () => client.listChannels(q),
+        routes: () => client.listRoutes({ ...q, profile: source.profile }),
+        triggers: () => client.listTriggers(q),
+        skills: () =>
+          client.listSkills({ ...q, cwd: source.cwd || source.home }),
+        memory: () =>
+          client.showMemory(source.harness, {
+            homes: source.homes,
+            profile: source.profile,
+            cwd: source.cwd || source.home,
+            full: false,
+          }),
+      };
+      const outcomes = await Promise.allSettled(
+        SOURCE_SECTIONS.map((name) => Promise.resolve().then(calls[name])),
+      );
+      const read = Object.fromEntries(
+        outcomes.flatMap((r, i) =>
+          r.status === "fulfilled" ? [[SOURCE_SECTIONS[i], r.value]] : [],
+        ),
+      );
+      const model = projectSourceInventory(read, { sourceKey });
+      outcomes.forEach((r, i) => {
+        if (r.status === "rejected") {
+          const name = SOURCE_SECTIONS[i];
+          // Exception messages can contain native paths or command lines. Keep them off this browser boundary.
+          const unsupported =
+          r.reason?.code === "unsupported_action" || r.reason?.code === -32020 ||
+            /unsupported|not supported|unavailable for/.test(
+              String(r.reason?.message),
+            );
+          model[name] = {
+            status: unsupported ? "unavailable" : "error",
+            items: [],
+            total: 0,
+            error: unsupported
+              ? `This source does not support ${name}.`
+              : `Could not read ${name} from this source.`,
+          };
+        }
+      });
+      return model;
+    },
+    async searchMemory(sourceKey, query) {
+      const source = get(sourceKey);
+      if (typeof query !== "string" || !query.trim() || query.length > 200)
+        throw new Error("Enter a search query of 1–200 characters");
+      try {
+        const read = await client.searchMemory(source.harness, query, {
+          homes: source.homes,
+          profile: source.profile,
+          cwd: source.cwd || source.home,
+          regex: false,
+        });
+        return projectMemoryMatches(read, { sourceKey });
+      } catch {
+        throw new Error("Could not search memory in this source.");
+      }
+    },
+  };
+}
+export function projectApprovals(read, { sourceKey = "source" } = {}) {
+  return rows(read)
+    .slice(0, 100)
+    .map((r) => ({
+      key: key(sourceKey, r.harness, r.id),
+      id: text(r.id, 300),
+      harness: text(r.harness, 100),
+      kind: text(r.kind, 100),
+      status: text(r.status, 100),
+      subject: text(r.subject),
+      session: text(r.session_id, 300) || null,
+      runtime: text(r.runtime_id, 300) || null,
+      ageMs: count(r.age_ms),
+      options:
+        r.status === "pending"
+          ? rows(r.options)
+              .slice(0, 30)
+              .map((o) => ({
+                id: text(o.id, 300),
+                label: text(o.label || o.id, 300),
+              }))
+          : [],
+    }));
+}
+/** A caller-owned live connection/session. This is not an allowlist or access-policy editor. */
+export function createApprovalHost({
+  client,
+  harness,
+  session,
+  sourceKey = "connection",
+  allowResolve = false,
+}) {
+  if (!harness || !session)
+    throw new Error("Approval scope requires a native harness and session");
+  let known = new Map();
+  const pending = new Set();
+  const list = async () => {
+    const native = rows(
+      await client.listApprovals({ harness, session }),
+    ).filter((row) => row.harness === harness && row.session_id === session);
+    const projected = projectApprovals(native, { sourceKey });
+    known = new Map(
+      projected.map((row, index) => [row.key, { row, native: native[index] }]),
+    );
+    return projected;
+  };
+  return {
+    list,
+    async resolve(key, optionId) {
+      if (!allowResolve || !known.has(key) || pending.has(key))
+        throw new Error("Decision unavailable for this connection");
+      pending.add(key);
+      try {
+        await list();
+        const request = known.get(key);
+        if (
+          request?.row.status !== "pending" ||
+          !request.native.options.some((option) => option.id === optionId)
+        )
+          throw new Error("This request or choice is no longer available");
+        const result = await client.resolveApproval(request.native.id, {
+          option_id: optionId,
+        });
+        if (
+          result.id !== request.native.id ||
+          result.option_id !== optionId ||
+          result.resolved !== true
+        )
+          throw new Error("The source did not confirm this decision");
+        known.delete(key);
+        return { key, optionId, resolved: true };
+      } finally {
+        pending.delete(key);
+      }
+    },
+  };
+}
+export function projectRuntimeState(state, { sourceKey = "runtime" } = {}) {
+  if (!state)
+    return {
+      source: sourceKey,
+      status: "unavailable",
+      observedAt: null,
+      activeTurns: null,
+      leases: null,
+      queuedMessages: null,
+      pendingRequests: null,
+      adapters: [],
+    };
+  const size = (value) =>
+    value && typeof value === "object" && !Array.isArray(value)
+      ? Object.keys(value).length
+      : null;
+  return {
+    source: sourceKey,
+    status: "ready",
+    observedAt: text(state.clock, 100) || null,
+    activeTurns: size(state.turns),
+    leases: size(state.leases),
+    queuedMessages:
+      size(state.queues) === null
+        ? null
+        : Object.values(state.queues).reduce((n, q) => n + rows(q).length, 0),
+    pendingRequests: size(state.pending_requests),
+    adapters: Object.entries(state.adapters || {})
+      .slice(0, 100)
+      .map(([name, value]) => ({
+        name: text(name, 200),
+        state: text(value.state, 100) || "unknown",
+        failures: count(value.breaker?.failures),
+        retryAt: text(value.breaker?.until, 100) || null,
+      })),
+  };
+}