@earendil-works/pi-radius-work 0.1.0

package/extensions/radius-google-workspaces.ts

@@ -0,0 +1,242 @@
+import fs from "node:fs";
+import http from "node:http";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const TOKENS_DIR =
+  process.env.GOOGLE_WORKSPACE_TOKENS_DIR ||
+  path.join(os.homedir(), ".pi", "google-workspace", "tokens");
+
+const GOOGLE_WORKSPACE_BROKER_CALLBACK_URL =
+  "https://radius.pi.dev/v1/oauth/google-workspaces/callback";
+
+type TokenPayload = {
+  access_token: string;
+  refresh_token?: string | null;
+  expiry_date: number;
+  scope?: string;
+  token_type?: string;
+  __authMode: "broker";
+  __email: string;
+};
+
+export default function googleWorkspacesExtension(pi: ExtensionAPI) {
+  pi.registerCommand("google-workspaces", {
+    description: "Connect a Google Workspace account via Radius",
+    handler: async (_args: string, ctx: any) => {
+      try {
+        ctx.ui.setStatus("google-workspaces", "Opening Google Workspace sign-in...");
+        const result = await loginGoogleWorkspaceAccount();
+        ctx.ui.notify(`Connected Google Workspace account: ${result.email}`, "info");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.setEditorText(message);
+        ctx.ui.notify("Google Workspace login failed", "error");
+      } finally {
+        ctx.ui.setStatus("google-workspaces", undefined);
+      }
+    },
+  });
+}
+
+async function loginGoogleWorkspaceAccount(): Promise<{ email: string; tokenPath: string }> {
+  ensureTokensDir();
+
+  const host = process.env.GOOGLE_WORKSPACE_CALLBACK_HOST || "localhost";
+  const port = await getAvailablePort();
+  const localCallbackUrl = `http://${host}:${port}/oauth2callback`;
+
+  const startUrl = new URL(getBrokerStartUrl());
+  startUrl.searchParams.set("return_to", localCallbackUrl);
+
+  const token = await waitForOAuthRedirect({
+    host,
+    port,
+    startUrl: startUrl.toString(),
+  });
+
+  const email = normalizeEmail(token.__email);
+  const tokenPath = tokenPathForEmail(email);
+  fs.writeFileSync(tokenPath, JSON.stringify(token, null, 2));
+  try {
+    fs.chmodSync(tokenPath, 0o600);
+  } catch {
+    // Ignore chmod failures on non-POSIX filesystems.
+  }
+
+  return { email, tokenPath };
+}
+
+function getBrokerStartUrl(): string {
+  return GOOGLE_WORKSPACE_BROKER_CALLBACK_URL.endsWith("/callback")
+    ? `${GOOGLE_WORKSPACE_BROKER_CALLBACK_URL.slice(0, -"/callback".length)}/start`
+    : `${GOOGLE_WORKSPACE_BROKER_CALLBACK_URL}/start`;
+}
+
+async function waitForOAuthRedirect(input: {
+  host: string;
+  port: number;
+  startUrl: string;
+}): Promise<TokenPayload> {
+  const { host, port, startUrl } = input;
+
+  const redirectPromise = new Promise<TokenPayload>((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      try {
+        if (!req.url || !req.url.startsWith("/oauth2callback")) {
+          res.statusCode = 404;
+          res.end("Not found");
+          return;
+        }
+
+        const parsed = new URL(req.url, `http://${host}:${port}`);
+        const errorCode = parsed.searchParams.get("error");
+        if (errorCode) {
+          const description =
+            parsed.searchParams.get("error_description") || "No additional details";
+          res.statusCode = 400;
+          res.end("Authentication failed.");
+          clearTimeout(timer);
+          server.close(() => reject(new Error(`Google OAuth error: ${errorCode}. ${description}`)));
+          return;
+        }
+
+        const email = parsed.searchParams.get("email");
+        const accessToken = parsed.searchParams.get("access_token");
+        const refreshToken = parsed.searchParams.get("refresh_token");
+        const scope = parsed.searchParams.get("scope");
+        const tokenType = parsed.searchParams.get("token_type");
+        const expiryDateRaw = parsed.searchParams.get("expiry_date");
+
+        if (!email || !accessToken || !expiryDateRaw) {
+          res.statusCode = 400;
+          res.end("Authentication failed: missing callback fields.");
+          clearTimeout(timer);
+          server.close(() =>
+            reject(new Error("Authentication failed: callback did not include email and tokens.")),
+          );
+          return;
+        }
+
+        const expiryDate = Number.parseInt(expiryDateRaw, 10);
+        if (Number.isNaN(expiryDate)) {
+          res.statusCode = 400;
+          res.end("Authentication failed: invalid expiry date.");
+          clearTimeout(timer);
+          server.close(() =>
+            reject(new Error("Authentication failed: callback expiry_date is invalid.")),
+          );
+          return;
+        }
+
+        const token: TokenPayload = {
+          access_token: accessToken,
+          refresh_token: refreshToken || null,
+          scope: scope || undefined,
+          token_type: tokenType || undefined,
+          expiry_date: expiryDate,
+          __authMode: "broker",
+          __email: normalizeEmail(email),
+        };
+
+        res.end("Authentication successful. You can close this tab.");
+        clearTimeout(timer);
+        server.close(() => resolve(token));
+      } catch (error) {
+        clearTimeout(timer);
+        server.close(() => reject(error));
+      }
+    });
+
+    const timer = setTimeout(
+      () => {
+        server.close(() =>
+          reject(new Error("Authentication timed out after 5 minutes. Please try again.")),
+        );
+      },
+      5 * 60 * 1000,
+    );
+
+    server.on("error", (error) => {
+      clearTimeout(timer);
+      reject(new Error(`OAuth callback server error: ${error.message}`));
+    });
+
+    server.listen(port, host, () => {
+      try {
+        openUrlInBrowser(startUrl);
+      } catch {
+        clearTimeout(timer);
+        server.close(() =>
+          reject(
+            new Error(`Could not open browser automatically. Open this URL manually:\n${startUrl}`),
+          ),
+        );
+      }
+    });
+  });
+
+  return redirectPromise;
+}
+
+function normalizeEmail(email: string): string {
+  const normalized = String(email || "")
+    .trim()
+    .toLowerCase();
+  if (!normalized) {
+    throw new Error("Google Workspace account email is missing.");
+  }
+  if (!/^[^@\s]+@[^@\s]+$/.test(normalized)) {
+    throw new Error(`Invalid email address: ${email}`);
+  }
+  return normalized;
+}
+
+function tokenFilenameForEmail(email: string): string {
+  return `${encodeURIComponent(normalizeEmail(email))}.json`;
+}
+
+function tokenPathForEmail(email: string): string {
+  return path.join(TOKENS_DIR, tokenFilenameForEmail(email));
+}
+
+function ensureTokensDir(): void {
+  fs.mkdirSync(TOKENS_DIR, { recursive: true });
+}
+
+function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const address = server.address();
+      const port = address && typeof address === "object" ? address.port : 0;
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+
+function openUrlInBrowser(targetUrl: string): void {
+  let command: string;
+  let args: string[];
+
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [targetUrl];
+  } else if (process.platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", targetUrl];
+  } else {
+    command = "xdg-open";
+    args = [targetUrl];
+  }
+
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}

package/extensions/radius-image-generation.ts

@@ -0,0 +1,207 @@
+import { Type } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Box, Spacer, Text } from "@earendil-works/pi-tui";
+
+type GatewayImageGenerationConfig = {
+  endpoint: string;
+};
+
+type GatewayConfig = {
+  baseUrl: string;
+  models: Array<{ id: string; name: string }>;
+  tools?: {
+    image_generation?: GatewayImageGenerationConfig;
+  };
+};
+
+type GatewayProvider = {
+  id: string;
+  name: string;
+  gateway: string;
+  apiKey?: string;
+  config: GatewayConfig;
+  authenticatedConfig?: GatewayConfig;
+};
+
+type ImageGenerationToolInput = {
+  prompt: string;
+  input_images?: Array<{
+    mediaType: string;
+    data: string;
+  }>;
+};
+
+type GatewayImageGenerationResponse = {
+  kind: "radius#image_generation";
+  model: string;
+  prompt: string;
+  images: Array<{
+    dataUrl: string;
+    mediaType: string;
+  }>;
+  text?: string;
+};
+
+const DEFAULT_GATEWAY = "https://radius.pi.dev";
+const DEFAULT_DEV_GATEWAY = "http://localhost:8788";
+const GATEWAY_PROVIDER_ID = "radius";
+const DEV_GATEWAY_PROVIDER_ID = "radius-dev";
+const GATEWAY_API_KEY_ENV = "PI_GATEWAY_API_KEY";
+const DEV_GATEWAY_API_KEY_ENV = "PI_DEV_GATEWAY_API_KEY";
+const IMAGE_GENERATION_TOOL_NAME = "image_generation";
+const IMAGE_GENERATION_MESSAGE_TYPE = "radius-image-generation";
+
+export default async function (pi: ExtensionAPI) {
+  const providers: GatewayProvider[] = [
+    {
+      id: GATEWAY_PROVIDER_ID,
+      name: "Radius",
+      gateway: process.env.PI_GATEWAY || DEFAULT_GATEWAY,
+      apiKey: process.env[GATEWAY_API_KEY_ENV],
+      config: createInitialGatewayConfig(process.env.PI_GATEWAY || DEFAULT_GATEWAY),
+    },
+  ];
+
+  const devGateway = process.env.PI_DEV_GATEWAY || DEFAULT_DEV_GATEWAY;
+  if (devGateway) {
+    providers.push({
+      id: DEV_GATEWAY_PROVIDER_ID,
+      name: "Radius (dev)",
+      gateway: devGateway,
+      apiKey: process.env[DEV_GATEWAY_API_KEY_ENV],
+      config: createInitialGatewayConfig(devGateway),
+    });
+  }
+
+  pi.registerMessageRenderer(IMAGE_GENERATION_MESSAGE_TYPE, (message, _options, theme) => {
+    const details = message.details as GatewayImageGenerationResponse | undefined;
+    const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
+    box.addChild(
+      new Text(theme.fg("customMessageLabel", "\x1b[1m[image_generation]\x1b[22m"), 0, 0),
+    );
+    box.addChild(new Spacer(1));
+    box.addChild(new Text(theme.fg("customMessageText", message.content as string), 0, 0));
+    if (details?.images?.[0]) {
+      const first = details.images[0];
+      const match = /^data:[^;]+;base64,(.*)$/s.exec(first.dataUrl);
+      if (match?.[1]) {
+        box.addChild(new Spacer(1));
+        box.addChild(
+          new Text(theme.fg("customMessageText", `[image attached: ${first.mediaType}]`), 0, 0),
+        );
+      }
+    }
+    return box;
+  });
+
+  pi.registerTool({
+    name: IMAGE_GENERATION_TOOL_NAME,
+    label: "Image Generation",
+    description:
+      "Generate or edit an image through Radius using Gemini 2.5 Flash Image via OpenRouter.",
+    promptSnippet: "Generate or edit an image through Radius",
+    parameters: Type.Object(
+      {
+        prompt: Type.String({ description: "Image generation prompt" }),
+        input_images: Type.Optional(
+          Type.Array(
+            Type.Object(
+              {
+                mediaType: Type.String(),
+                data: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+          ),
+        ),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(
+      _toolCallId: string,
+      params: ImageGenerationToolInput,
+      signal: AbortSignal | undefined,
+      _onUpdate: unknown,
+      ctx: any,
+    ) {
+      const provider = selectProvider(providers, ctx);
+      const config = getEffectiveConfig(provider).tools?.image_generation;
+      if (!config) {
+        throw new Error("Radius image generation is not configured");
+      }
+      const apiKey = await getApiKey(provider, ctx);
+      const response = await fetch(config.endpoint, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${apiKey}`,
+          accept: "application/json",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          prompt: params.prompt,
+          input_images: params.input_images,
+        }),
+        signal,
+      });
+      if (!response.ok) {
+        throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+      }
+      const payload = (await response.json()) as GatewayImageGenerationResponse;
+      const summary = `Generated ${payload.images.length} image(s) with ${payload.model}.`;
+      pi.sendMessage({
+        customType: IMAGE_GENERATION_MESSAGE_TYPE,
+        content: summary,
+        display: true,
+        details: payload,
+      });
+      const content: Array<any> = [{ type: "text", text: JSON.stringify(payload, null, 2) }];
+      for (const image of payload.images) {
+        const match = /^data:[^;]+;base64,(.*)$/s.exec(image.dataUrl);
+        if (match?.[1]) {
+          content.push({ type: "image", data: match[1], mimeType: image.mediaType });
+        }
+      }
+      return {
+        content,
+        details: { provider: provider.id, ...payload },
+      };
+    },
+  });
+}
+
+function selectProvider(providers: GatewayProvider[], ctx: any): GatewayProvider {
+  const provider = providers.find((candidate) => candidate.id === ctx.model?.provider);
+  if (!provider) {
+    throw new Error("image_generation is only available when the current model is a Radius model");
+  }
+  return provider;
+}
+
+async function getApiKey(provider: GatewayProvider, ctx: any): Promise<string> {
+  if (provider.apiKey) {
+    return provider.apiKey;
+  }
+  const result = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+  if (!result.ok || !result.apiKey) {
+    throw new Error(result.ok ? "Missing gateway API key" : result.error);
+  }
+  return result.apiKey;
+}
+
+function getEffectiveConfig(provider?: GatewayProvider): GatewayConfig {
+  return (
+    provider?.authenticatedConfig ?? provider?.config ?? createInitialGatewayConfig(DEFAULT_GATEWAY)
+  );
+}
+
+function createInitialGatewayConfig(gateway: string): GatewayConfig {
+  return {
+    baseUrl: `${gateway.replace(/\/+$/u, "")}/v1`,
+    models: [],
+    tools: {
+      image_generation: {
+        endpoint: `${gateway.replace(/\/+$/u, "")}/v1/images/generate`,
+      },
+    },
+  };
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@earendil-works/pi-radius-work",
+  "version": "0.1.0",
+  "description": "Radius Google Workspace and image generation extensions for Pi",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/earendil-works/pi-extensions.git",
+    "directory": "packages/pi-radius-work"
+  },
+  "type": "module",
+  "files": [
+    "extensions/radius-google-workspaces.ts",
+    "extensions/radius-image-generation.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/radius-google-workspaces.ts",
+      "./extensions/radius-image-generation.ts"
+    ]
+  }
+}