aidevops 3.21.12 → 3.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aidevops",
-  "version": "3.21.12",
+  "version": "3.22.0",
   "description": "AI DevOps Framework - AI-assisted development workflows, code quality, and deployment automation",
   "type": "module",
   "workspaces": [
@@ -83,6 +83,17 @@
     "aidevops-*-lib.sh",
     "setup.sh",
     "setup-modules/",
+    "bun.lock",
+    "packages/gui-shared/package.json",
+    "packages/gui-shared/src/",
+    "packages/gui-api/package.json",
+    "packages/gui-api/src/",
+    "packages/gui-web/package.json",
+    "packages/gui-web/index.html",
+    "packages/gui-web/src/",
+    "packages/gui-web/vite.config.ts",
+    "packages/gui-desktop/package.json",
+    "packages/gui-desktop/scripts/",
     "VERSION",
     "scripts/npm-postinstall.cjs",
     "templates/"

package/packages/gui-api/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@aidevops/gui-api",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/app.ts"
+  }
+}

package/packages/gui-api/src/app.ts

@@ -0,0 +1,49 @@
+import { Hono } from "hono";
+import { BANNED_ROUTE_PATTERNS, FILE_EXPLORER_ROUTE_MANIFEST, STATUS_ROUTE_MANIFEST } from "../../gui-shared/src";
+import { readFileExplorer } from "./file-adapter";
+import { readStatus } from "./status-adapter";
+
+export function createGuiApiApp() {
+  const app = new Hono();
+
+  app.get(STATUS_ROUTE_MANIFEST.route, (context) => {
+    return context.json(readStatus());
+  });
+
+  app.get(FILE_EXPLORER_ROUTE_MANIFEST.route, (context) => {
+    const root = context.req.param("root");
+    const path = context.req.query("path") ?? "";
+    const response = readFileExplorer(root, path);
+    const status = response.ok ? 200 : response.errors.includes("unknown_file_root") ? 404 : 400;
+
+    return context.json(response, status);
+  });
+
+  for (const route of BANNED_ROUTE_PATTERNS) {
+    app.post(route, (context) => {
+      return context.json(
+        {
+          ok: false,
+          operation_id: "capabilities.read",
+          errors: ["write_actions_disabled"],
+        },
+        405,
+      );
+    });
+  }
+
+  app.notFound((context) => {
+    return context.json(
+      {
+        ok: false,
+        operation_id: "capabilities.read",
+        errors: ["unknown_route"],
+      },
+      404,
+    );
+  });
+
+  return app;
+}
+
+export const app = createGuiApiApp();

package/packages/gui-api/src/file-adapter.ts

@@ -0,0 +1,207 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import {
+  assertNoSecretSentinels,
+  createEnvelope,
+  GUI_FILE_ROOTS,
+  type GuiFileEntry,
+  type GuiFileExplorerData,
+  type GuiFilePreview,
+  type GuiFileRootDefinition,
+  type GuiResponseEnvelope,
+} from "../../gui-shared/src";
+
+const MAX_ENTRIES = 80;
+const MAX_PREVIEW_CHARS = 48_000;
+
+interface FileEnvelopeInput {
+  currentRelativePath: string;
+  entries: GuiFileEntry[];
+  errors: string[];
+  observedAt?: string;
+  root: GuiFileRootDefinition;
+  selectedPreview: GuiFilePreview | null;
+}
+
+export function readFileExplorer(
+  rootId: string,
+  requestedPath = "",
+  observedAt?: string,
+): GuiResponseEnvelope<GuiFileExplorerData> {
+  const root = GUI_FILE_ROOTS.find((entry) => entry.id === rootId);
+  if (root === undefined) {
+    return createFileEnvelope({
+      root: unknownRoot(),
+      currentRelativePath: "",
+      entries: [],
+      selectedPreview: null,
+      errors: ["unknown_file_root"],
+      observedAt,
+    });
+  }
+
+  const rootPath = resolvePathRef(root.path_ref);
+  const targetPath = resolve(rootPath, requestedPath);
+  if (!isInsideRoot(rootPath, targetPath)) {
+    return createFileEnvelope({
+      root,
+      currentRelativePath: "",
+      entries: [],
+      selectedPreview: blockedPreview(root, "Path is outside the allowed root."),
+      errors: ["path_outside_root"],
+      observedAt,
+    });
+  }
+
+  if (!existsSync(rootPath)) {
+    return createFileEnvelope({
+      root,
+      currentRelativePath: "",
+      entries: [],
+      selectedPreview: null,
+      errors: ["root_missing"],
+      observedAt,
+    });
+  }
+
+  const targetExists = existsSync(targetPath);
+  const targetStats = targetExists ? statSync(targetPath) : null;
+  const browsePath = targetStats?.isFile() ? dirname(targetPath) : targetPath;
+  const currentRelativePath = toRelativePath(rootPath, browsePath);
+  const entries = targetExists && existsSync(browsePath) ? readEntries(root, rootPath, browsePath) : [];
+  const preview = targetStats?.isFile()
+    ? readPreview(root, rootPath, targetPath)
+    : null;
+
+  return createFileEnvelope({
+    root,
+    currentRelativePath,
+    entries,
+    selectedPreview: preview,
+    errors: targetExists ? [] : ["path_missing"],
+    observedAt,
+  });
+}
+
+function createFileEnvelope(input: FileEnvelopeInput): GuiResponseEnvelope<GuiFileExplorerData> {
+  const data: GuiFileExplorerData = {
+    root: input.root,
+    current_path_ref: toPathRef(input.root.path_ref, input.currentRelativePath),
+    current_relative_path: input.currentRelativePath,
+    entries: input.entries,
+    selected_preview: input.selectedPreview,
+    entry_limit: MAX_ENTRIES,
+  };
+  const envelope = createEnvelope({
+    operation_id: "filesystem.read",
+    source: {
+      surface: "filesystem",
+      authority: "local read-only allowlist",
+      path_refs: [input.root.path_ref],
+    },
+    data,
+    errors: input.errors,
+    observed_at: input.observedAt,
+  });
+
+  assertNoSecretSentinels(envelope);
+  return envelope;
+}
+
+function readEntries(root: GuiFileRootDefinition, rootPath: string, browsePath: string): GuiFileEntry[] {
+  return readdirSync(browsePath, { withFileTypes: true })
+    .filter((entry) => !entry.name.startsWith("."))
+    .sort((first, second) => sortEntry(first.isDirectory(), first.name, second.isDirectory(), second.name))
+    .slice(0, MAX_ENTRIES)
+    .map((entry) => {
+      const entryPath = join(browsePath, entry.name);
+      const relativePath = toRelativePath(rootPath, entryPath);
+      const extension = entry.isDirectory() ? "" : extname(entry.name).toLowerCase();
+      return {
+        name: entry.name,
+        kind: entry.isDirectory() ? "directory" : "file",
+        path_ref: toPathRef(root.path_ref, relativePath),
+        relative_path: relativePath,
+        extension,
+        preview_allowed: root.id === "agents" && entry.isFile(),
+      };
+    });
+}
+
+function readPreview(root: GuiFileRootDefinition, rootPath: string, targetPath: string): GuiFilePreview {
+  const relativePath = toRelativePath(rootPath, targetPath);
+  const pathRef = toPathRef(root.path_ref, relativePath);
+  if (root.preview_policy !== "agents_markdown_and_code") {
+    return {
+      path_ref: pathRef,
+      relative_path: relativePath,
+      mode: "blocked",
+      language: "",
+      content: "",
+      truncated: false,
+      reason: "Content preview is disabled for this root until redaction and write-action policies land.",
+    };
+  }
+
+  const content = readFileSync(targetPath, "utf8");
+  const extension = extname(targetPath).toLowerCase();
+  return {
+    path_ref: pathRef,
+    relative_path: relativePath,
+    mode: extension === ".md" ? "markdown" : extension.length > 0 ? "code" : "text",
+    language: extension.replace(/^\./, "") || "text",
+    content: content.length > MAX_PREVIEW_CHARS ? content.slice(0, MAX_PREVIEW_CHARS) : content,
+    truncated: content.length > MAX_PREVIEW_CHARS,
+    reason: "",
+  };
+}
+
+function blockedPreview(root: GuiFileRootDefinition, reason: string): GuiFilePreview {
+  return {
+    path_ref: root.path_ref,
+    relative_path: "",
+    mode: "blocked",
+    language: "",
+    content: "",
+    truncated: false,
+    reason,
+  };
+}
+
+function unknownRoot(): GuiFileRootDefinition {
+  return {
+    id: "agents",
+    label: "Unknown root",
+    path_ref: "~",
+    description: "The requested file root is not in the GUI allowlist.",
+    preview_policy: "metadata_only",
+  };
+}
+
+function resolvePathRef(pathRef: string): string {
+  if (!pathRef.startsWith("~/")) {
+    return resolve(pathRef);
+  }
+
+  return resolve(join(process.env.HOME ?? "", pathRef.slice(2)));
+}
+
+function isInsideRoot(rootPath: string, targetPath: string): boolean {
+  return targetPath === rootPath || targetPath.startsWith(`${rootPath}${sep}`);
+}
+
+function toRelativePath(rootPath: string, targetPath: string): string {
+  return relative(rootPath, targetPath).split(sep).filter(Boolean).join("/");
+}
+
+function toPathRef(rootPathRef: string, relativePath: string): string {
+  return relativePath.length > 0 ? `${rootPathRef}/${relativePath}` : rootPathRef;
+}
+
+function sortEntry(firstIsDirectory: boolean, firstName: string, secondIsDirectory: boolean, secondName: string): number {
+  if (firstIsDirectory !== secondIsDirectory) {
+    return firstIsDirectory ? -1 : 1;
+  }
+
+  return firstName.localeCompare(secondName);
+}

package/packages/gui-api/src/server.ts

@@ -0,0 +1,12 @@
+import { serve } from "bun";
+import { app } from "./app";
+
+const port = Number.parseInt(process.env.AIDEVOPS_GUI_API_PORT ?? "8787", 10);
+
+serve({
+  fetch: app.fetch,
+  hostname: "127.0.0.1",
+  port,
+});
+
+console.log(`aidevops GUI API listening read-only on http://127.0.0.1:${port}`);

package/packages/gui-api/src/status-adapter-utils.ts

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+
+export function readJsonObject(pathName: string): { health: "present" | "missing" | "invalid"; value: Record<string, unknown> } {
+  if (!existsSync(pathName)) {
+    return { health: "missing", value: {} };
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(pathName, "utf8"));
+    return isRecord(parsed) ? { health: "present", value: parsed } : { health: "invalid", value: {} };
+  } catch {
+    return { health: "invalid", value: {} };
+  }
+}
+
+export function safeRealpath(pathName: string): string | null {
+  try {
+    return realpathSync(pathName);
+  } catch {
+    return null;
+  }
+}
+
+export function collapseHome(pathName: string): string {
+  const home = process.env.HOME ?? "";
+  if (home.length > 0 && pathName === home) {
+    return "~";
+  }
+  if (home.length > 0 && pathName.startsWith(`${home}/`)) {
+    return `~/${pathName.slice(home.length + 1)}`;
+  }
+  return pathName;
+}
+
+export function booleanField(value: Record<string, unknown>, key: string): boolean | null {
+  const field = value[key];
+  return typeof field === "boolean" ? field : null;
+}
+
+export function numberField(value: Record<string, unknown>, key: string): number | null {
+  const field = value[key];
+  return typeof field === "number" && Number.isFinite(field) ? field : null;
+}
+
+export function featureList(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0).sort();
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean).sort();
+  }
+  if (isRecord(value)) {
+    return Object.entries(value)
+      .filter(([, enabled]) => enabled === true)
+      .map(([feature]) => feature)
+      .sort();
+  }
+  return [];
+}
+
+export function formatNullableEpochField(value: unknown): string | null {
+  if (value === null || value === undefined || value === 0) {
+    return null;
+  }
+  return formatEpochField(value);
+}
+
+export function formatEpochField(value: unknown): string {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return "unknown";
+  }
+  const millis = value > 9_999_999_999 ? value : value * 1000;
+  return new Date(millis).toISOString();
+}
+
+export function cooldownReady(cooldownUntil: string | null, now: number): boolean {
+  if (cooldownUntil === null) {
+    return true;
+  }
+  const parsed = Date.parse(cooldownUntil);
+  return Number.isNaN(parsed) || parsed <= now;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function stringField(value: Record<string, unknown>, key: string): string | undefined {
+  const field = value[key];
+  return typeof field === "string" && field.length > 0 ? field : undefined;
+}
+
+export function expandHome(pathRef: string): string {
+  if (!pathRef.startsWith("~/")) {
+    return pathRef;
+  }
+
+  return join(process.env.HOME ?? "", pathRef.slice(2));
+}
+
+export function readOptionalText(pathName: string): string | null {
+  if (!existsSync(pathName)) {
+    return null;
+  }
+
+  return readFileSync(pathName, "utf8").trim();
+}