@microsoft/agent-governance-antigravity-cli 4.0.0

package/assets/extensions/agt-global-policy/lib/sdk-loader.mjs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { existsSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const VENDORED_SDK_RELATIVE_PATH =
+  "./vendor/agent-governance-sdk/node_modules/@microsoft/agent-governance-sdk/dist/index.js";
+
+export async function loadAgentGovernanceSdk({
+  env = process.env,
+  extensionRoot = import.meta.dirname,
+} = {}) {
+  const extensionRootPath = realpathSync(resolve(extensionRoot));
+  const vendoredSdkPath = resolve(extensionRootPath, VENDORED_SDK_RELATIVE_PATH);
+  const candidates = [
+    {
+      path: vendoredSdkPath,
+      source: "vendored",
+    },
+  ];
+
+  const attempted = [];
+  for (const candidate of candidates) {
+    attempted.push(candidate.path);
+    if (!existsSync(candidate.path)) {
+      continue;
+    }
+
+    const canonicalCandidatePath = realpathSync(candidate.path);
+    const loaded = await import(pathToFileURL(canonicalCandidatePath).href);
+    return {
+      path: canonicalCandidatePath,
+      sdk: loaded.default ?? loaded,
+      source: candidate.source,
+    };
+  }
+
+  throw new Error(
+    [
+      "Unable to locate the vendored Agent Governance TypeScript SDK.",
+      `Checked paths: ${attempted.join("; ")}`,
+    ].join(" "),
+  );
+}

package/assets/extensions/agt-global-policy/mcp/server.mjs

@@ -0,0 +1,224 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { fileURLToPath } from "node:url";
+
+import { checkArbitraryText, formatPolicySummary, getPolicyStatus, loadPolicy } from "../lib/policy.mjs";
+
+const SERVER_INFO = {
+  name: "agt-global-policy",
+  version: "3.3.0",
+};
+const PROTOCOL_VERSION = "2024-11-05";
+const JSONRPC_VERSION = "2.0";
+const HEADER_SEPARATOR = Buffer.from("\r\n\r\n", "utf8");
+const extensionRoot = fileURLToPath(new URL("..", import.meta.url));
+
+const tools = [
+  {
+    name: "agt_policy_status",
+    description: "Return the active AGT Antigravity policy runtime status and summary.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agt_policy_check_text",
+    description: "Run AGT poisoning, MCP, and prompt-defense checks against arbitrary text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "The text to inspect.",
+        },
+      },
+      required: ["text"],
+      additionalProperties: false,
+    },
+  },
+];
+
+let inputBuffer = Buffer.alloc(0);
+
+process.stdin.on("data", (chunk) => {
+  inputBuffer = Buffer.concat([inputBuffer, chunk]);
+  void drainInputBuffer();
+});
+
+async function drainInputBuffer() {
+  while (true) {
+    const headerEnd = inputBuffer.indexOf(HEADER_SEPARATOR);
+    if (headerEnd === -1) {
+      return;
+    }
+
+    const headerText = inputBuffer.subarray(0, headerEnd).toString("utf8");
+    const contentLength = getContentLength(headerText);
+    if (contentLength === null) {
+      inputBuffer = Buffer.alloc(0);
+      writeError(null, -32700, "Missing or invalid Content-Length header.");
+      return;
+    }
+
+    const messageStart = headerEnd + HEADER_SEPARATOR.length;
+    const messageEnd = messageStart + contentLength;
+    if (inputBuffer.length < messageEnd) {
+      return;
+    }
+
+    const payload = inputBuffer.subarray(messageStart, messageEnd).toString("utf8");
+    inputBuffer = inputBuffer.subarray(messageEnd);
+
+    let message;
+    try {
+      message = JSON.parse(payload);
+    } catch {
+      writeError(null, -32700, "Invalid JSON payload.");
+      continue;
+    }
+
+    await handleMessage(message);
+  }
+}
+
+function getContentLength(headerText) {
+  for (const line of headerText.split("\r\n")) {
+    const [name, ...valueParts] = line.split(":");
+    if (name?.toLowerCase() !== "content-length") {
+      continue;
+    }
+    const parsed = Number.parseInt(valueParts.join(":").trim(), 10);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+async function handleMessage(message) {
+  if (message?.jsonrpc !== JSONRPC_VERSION || typeof message?.method !== "string") {
+    writeError(message?.id ?? null, -32600, "Invalid JSON-RPC request.");
+    return;
+  }
+
+  if (message.method === "notifications/initialized") {
+    return;
+  }
+
+  try {
+    if (message.method === "initialize") {
+      writeResult(message.id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+          tools: {},
+        },
+        serverInfo: SERVER_INFO,
+      });
+      return;
+    }
+
+    if (message.method === "ping") {
+      writeResult(message.id, {});
+      return;
+    }
+
+    if (message.method === "tools/list") {
+      writeResult(message.id, { tools });
+      return;
+    }
+
+    if (message.method === "tools/call") {
+      writeResult(message.id, await callTool(message.params ?? {}));
+      return;
+    }
+
+    writeError(message.id ?? null, -32601, `Unknown method: ${message.method}`);
+  } catch (error) {
+    writeError(message.id ?? null, -32603, error instanceof Error ? error.message : String(error));
+  }
+}
+
+async function callTool(params) {
+  const state = await loadPolicy({ extensionRoot });
+  const args = params.arguments ?? {};
+
+  if (params.name === "agt_policy_status") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              summary: formatPolicySummary(state),
+              status: getPolicyStatus(state),
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  }
+
+  if (params.name === "agt_policy_check_text") {
+    const text = String(args.text ?? "").trim();
+    if (!text) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "The `text` argument is required.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(checkArbitraryText(state, text), null, 2),
+        },
+      ],
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Unknown tool: ${params.name}`,
+      },
+    ],
+    isError: true,
+  };
+}
+
+function writeResult(id, result) {
+  if (id === undefined || id === null) {
+    return;
+  }
+  writeMessage({
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result,
+  });
+}
+
+function writeError(id, code, message) {
+  writeMessage({
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error: {
+      code,
+      message,
+    },
+  });
+}
+
+function writeMessage(payload) {
+  const body = JSON.stringify(payload);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+}

package/assets/extensions/agt-global-policy/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/bin/agt-antigravity.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { runCli } from "../lib/cli.mjs";
+
+const exitCode = await runCli(process.argv.slice(2));
+process.exitCode = exitCode;