@dcl-regenesislabs/opendcl 0.1.0-22234509684.commit-63dfd19

package/extensions/dcl-setup.ts

@@ -0,0 +1,96 @@
+/**
+ * DCL Setup Extension
+ *
+ * Registers the /setup command that walks users through
+ * configuring an LLM provider — either via subscription login
+ * (easiest) or by pasting an API key.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export const LOGIN_PROVIDERS = [
+  { id: "anthropic",       label: "Anthropic (Claude Pro/Max)" },
+  { id: "openai-codex",    label: "OpenAI (ChatGPT Plus/Pro)" },
+  { id: "github-copilot",  label: "GitHub Copilot" },
+  { id: "google-gemini-cli", label: "Google (Gemini)" },
+];
+
+export const API_KEY_PROVIDERS = [
+  { id: "anthropic",   label: "Anthropic (Claude)",    envVar: "ANTHROPIC_API_KEY" },
+  { id: "openai",      label: "OpenAI (GPT)",          envVar: "OPENAI_API_KEY" },
+  { id: "google",      label: "Google (Gemini)",        envVar: "GEMINI_API_KEY" },
+  { id: "groq",        label: "Groq",                  envVar: "GROQ_API_KEY" },
+  { id: "mistral",     label: "Mistral",               envVar: "MISTRAL_API_KEY" },
+  { id: "xai",         label: "xAI (Grok)",            envVar: "XAI_API_KEY" },
+  { id: "openrouter",  label: "OpenRouter",             envVar: "OPENROUTER_API_KEY" },
+  { id: "cerebras",    label: "Cerebras",               envVar: "CEREBRAS_API_KEY" },
+  { id: "huggingface", label: "Hugging Face",           envVar: "HF_TOKEN" },
+];
+
+export async function readAuthConfig(authPath: string): Promise<Record<string, unknown>> {
+  try {
+    const content = await readFile(authPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+export async function writeAuthKey(authPath: string, providerId: string, apiKey: string): Promise<void> {
+  const existing = await readAuthConfig(authPath);
+  existing[providerId] = { type: "api_key", key: apiKey };
+  await mkdir(dirname(authPath), { recursive: true });
+  await writeFile(authPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+
+const LOGIN_SUFFIX = " (Login with subscription)";
+const API_KEY_SUFFIX = " (API key)";
+
+const extension: ExtensionFactory = (pi) => {
+  pi.registerCommand("setup", {
+    description: "Configure an LLM provider (login or API key)",
+    handler: async (_args, ctx) => {
+      const loginLabels = LOGIN_PROVIDERS.map((p) => p.label + LOGIN_SUFFIX);
+      const apiKeyLabels = API_KEY_PROVIDERS.map((p) => p.label + API_KEY_SUFFIX);
+      const allLabels = [...loginLabels, ...apiKeyLabels];
+
+      const selected = await ctx.ui.select("Choose a provider", allLabels);
+      if (!selected) {
+        ctx.ui.notify("Setup cancelled.", "info");
+        return;
+      }
+
+      if (selected.endsWith(LOGIN_SUFFIX)) {
+        ctx.ui.notify("Type /login and select your provider to authenticate.", "info");
+        return;
+      }
+
+      const provider = API_KEY_PROVIDERS.find((p) => p.label + API_KEY_SUFFIX === selected);
+      if (!provider) {
+        ctx.ui.notify("Invalid selection.", "error");
+        return;
+      }
+
+      const apiKey = await ctx.ui.input(`Paste your ${provider.label} API key`);
+      if (!apiKey) {
+        ctx.ui.notify("Setup cancelled.", "info");
+        return;
+      }
+
+      // Persist to auth.json for future sessions
+      const authPath = join(homedir(), ".opendcl", "agent", "auth.json");
+      await writeAuthKey(authPath, provider.id, apiKey);
+
+      // Register in-memory so models are available immediately
+      // (session.reload() does not re-read auth.json)
+      pi.registerProvider(provider.id, { apiKey });
+
+      ctx.ui.notify(`${provider.label} configured! Press Ctrl+P to select a model.`, "info");
+    },
+  });
+};
+
+export default extension;

package/extensions/dcl-status.ts

@@ -0,0 +1,88 @@
+/**
+ * DCL Status Extension
+ *
+ * Shows elapsed time and output token count in the working message spinner
+ * during LLM inference, replacing the default "Working..." text with something
+ * like "Thinking... (23s · ↓ 1.2k tokens)".
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+
+export function formatElapsed(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return `${count}`;
+  return `${(count / 1000).toFixed(1)}k`;
+}
+
+type Phase = "Thinking" | "Generating" | "Tool call";
+
+const extension: ExtensionFactory = (pi) => {
+  let startTime = 0;
+  let outputTokens = 0;
+  let phase: Phase = "Thinking";
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  function update(ctx: { ui: { setWorkingMessage(msg?: string): void } }) {
+    const elapsed = formatElapsed(Date.now() - startTime);
+    const tokens = formatTokens(outputTokens);
+    ctx.ui.setWorkingMessage(`${phase}... (${elapsed} · ↓ ${tokens} tokens)`);
+  }
+
+  function cleanup(ctx: { ui: { setWorkingMessage(msg?: string): void } }) {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    ctx.ui.setWorkingMessage();
+  }
+
+  pi.on("turn_start", async (event, ctx) => {
+    startTime = (event as { timestamp?: number }).timestamp ?? Date.now();
+    outputTokens = 0;
+    phase = "Thinking";
+    cleanup(ctx);
+    update(ctx);
+    timer = setInterval(() => update(ctx), 1000);
+  });
+
+  pi.on("message_update", async (event, ctx) => {
+    const e = event as {
+      message?: { usage?: { output?: number } };
+      assistantMessageEvent?: { type?: string };
+    };
+
+    if (e.message?.usage?.output != null) {
+      outputTokens = e.message.usage.output;
+    }
+
+    const ameType = e.assistantMessageEvent?.type;
+    if (ameType) {
+      if (ameType.startsWith("thinking")) {
+        phase = "Thinking";
+      } else if (ameType === "text_delta") {
+        phase = "Generating";
+      } else if (ameType.startsWith("tool")) {
+        phase = "Tool call";
+      }
+    }
+
+    update(ctx);
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    cleanup(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    cleanup(ctx);
+  });
+};
+
+export default extension;

package/extensions/dcl-tasks.ts

@@ -0,0 +1,102 @@
+/**
+ * DCL Tasks Extension
+ *
+ * Provides the `tasks` tool (LLM-callable) for listing/stopping background tasks,
+ * and the `/tasks` command for interactive management via a shared registry.
+ * Also maintains a footer status indicator and cleans up on shutdown.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { processes } from "./process-registry.js";
+
+function updateStatus(ctx: { ui: { setStatus(key: string, text: string | undefined): void } }): void {
+  const names = Array.from(processes.values()).map((p) => p.name.toLowerCase());
+  ctx.ui.setStatus("tasks", names.length > 0 ? `▶ ${names.join(", ")}` : undefined);
+}
+
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }], details: undefined };
+}
+
+const extension: ExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: "tasks",
+    label: "Tasks",
+    description: "List or stop running background tasks (preview server, etc.).",
+    parameters: Type.Object({
+      action: StringEnum(["list", "stop"] as const, { description: "Action to perform" }),
+      name: Type.Optional(Type.String({ description: "Task name to stop (for stop action)" })),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      if (params.action === "list") {
+        if (processes.size === 0) {
+          return textResult("No background tasks running.");
+        }
+        const lines = Array.from(processes.entries()).map(
+          ([id, p]) => `- ${id}: ${p.name}${p.info ? ` (${p.info})` : ""}`
+        );
+        return textResult(`Running tasks:\n${lines.join("\n")}`);
+      }
+
+      if (params.action === "stop") {
+        if (!params.name) {
+          return textResult("Please specify a task name to stop.");
+        }
+        const proc = processes.get(params.name);
+        if (!proc) {
+          const available = Array.from(processes.keys()).join(", ") || "none";
+          return textResult(`Task "${params.name}" not found. Running tasks: ${available}`);
+        }
+        proc.kill();
+        processes.delete(params.name);
+        updateStatus(ctx);
+        return textResult(`${proc.name} stopped.`);
+      }
+
+      return textResult(`Unknown action: ${params.action}`);
+    },
+  });
+
+  pi.registerCommand("tasks", {
+    description: "Manage running background tasks",
+    handler: async (_args, ctx) => {
+      if (processes.size === 0) {
+        ctx.ui.notify("No background tasks running.", "info");
+        return;
+      }
+
+      const entries = Array.from(processes.entries());
+      const options = entries.map(([_id, p]) => (p.info ? `${p.name} — ${p.info}` : p.name));
+      options.push("Close menu");
+
+      const selected = await ctx.ui.select("Background tasks", options);
+
+      if (!selected || selected === "Close menu") return;
+
+      const idx = options.indexOf(selected);
+      if (idx < 0 || idx >= entries.length) return;
+
+      const [id, proc] = entries[idx];
+
+      const action = await ctx.ui.select(proc.name, ["Stop it", "Back"]);
+      if (action !== "Stop it") return;
+
+      proc.kill();
+      processes.delete(id);
+      ctx.ui.notify(`${proc.name} stopped.`, "info");
+      updateStatus(ctx);
+    },
+  });
+
+  pi.on("session_shutdown", () => {
+    for (const [id, proc] of processes) {
+      proc.kill();
+      processes.delete(id);
+    }
+  });
+};
+
+export { updateStatus };
+export default extension;

package/extensions/dcl-update-check.ts

@@ -0,0 +1,79 @@
+/**
+ * Update check extension for OpenDCL.
+ * On session start, checks npm registry for a newer version and notifies the user.
+ * Fails silently on network errors or if the package isn't published yet.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const FETCH_TIMEOUT_MS = 5000;
+const PACKAGE_JSON_PATH = join(__dirname, "..", "package.json");
+
+/** Read and parse the project's package.json. */
+function readPackageJson(): { name?: string; version?: string } {
+  try {
+    return JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/** Read the package name from package.json. */
+export function getPackageName(): string {
+  return readPackageJson().name || "@dcl-regenesislabs/opendcl";
+}
+
+/** Read the installed version from package.json. */
+export function getInstalledVersion(): string {
+  return readPackageJson().version || "0.0.0";
+}
+
+/** Fetch the latest published version from npm registry. */
+export async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const registryUrl = `https://registry.npmjs.org/${getPackageName()}/latest`;
+    const res = await fetch(registryUrl, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version?: string };
+    return data.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Compare two semver strings. Returns true if latest is newer than current. */
+export function isNewerVersion(current: string, latest: string): boolean {
+  const currentParts = current.split(".").map((n) => parseInt(n, 10) || 0);
+  const latestParts = latest.split(".").map((n) => parseInt(n, 10) || 0);
+  const length = Math.max(currentParts.length, latestParts.length);
+  for (let i = 0; i < length; i++) {
+    const currentPart = currentParts[i] || 0;
+    const latestPart = latestParts[i] || 0;
+    if (latestPart > currentPart) return true;
+    if (latestPart < currentPart) return false;
+  }
+  return false;
+}
+
+const extension: ExtensionFactory = (pi) => {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    // Fire-and-forget: don't block session startup
+    fetchLatestVersion().then((latest) => {
+      if (latest && isNewerVersion(getInstalledVersion(), latest)) {
+        ctx.ui.notify(`OpenDCL v${latest} is available. Run: npm install -g ${getPackageName()}`, "info");
+      }
+    });
+  });
+};
+
+export default extension;

package/extensions/dcl-validate.ts

@@ -0,0 +1,80 @@
+/**
+ * DCL Validate Extension
+ *
+ * Hooks into write tool calls — after writing .ts/.tsx files, runs
+ * `npx tsc --noEmit` to catch type errors immediately.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { join, dirname } from "node:path";
+import { fileExists, findSceneRoot } from "./scene-utils.js";
+
+const extension: ExtensionFactory = (pi) => {
+  let validationTimeout: ReturnType<typeof setTimeout> | null = null;
+  let lastValidationTime = 0;
+  const DEBOUNCE_MS = 2000; // Don't validate more than once every 2 seconds
+
+  pi.on("tool_result", async (event, ctx) => {
+    // Only react to write tool results for .ts/.tsx files
+    if (event.toolName !== "write" || event.isError) return;
+
+    const filePath = (event.input as { path?: string }).path ?? "";
+    if (!filePath.match(/\.tsx?$/)) return;
+
+    // Find scene root from the written file's directory
+    const fileDir = dirname(filePath);
+    const sceneRoot = await findSceneRoot(fileDir);
+    if (!sceneRoot) return;
+
+    // Check for tsconfig.json
+    if (!(await fileExists(join(sceneRoot, "tsconfig.json")))) return;
+
+    // Check for node_modules (tsc needs @dcl/sdk types)
+    if (!(await fileExists(join(sceneRoot, "node_modules")))) return;
+
+    // Debounce validation
+    const now = Date.now();
+    if (now - lastValidationTime < DEBOUNCE_MS) return;
+    lastValidationTime = now;
+
+    // Clear any pending validation
+    if (validationTimeout) {
+      clearTimeout(validationTimeout);
+    }
+
+    // Run validation after a short delay (allows multiple writes to batch)
+    validationTimeout = setTimeout(async () => {
+      try {
+        const result = await pi.exec("npx", ["tsc", "--noEmit", "--pretty"], {
+          cwd: sceneRoot,
+          timeout: 30000,
+        });
+
+        if (result.code !== 0 && result.stdout) {
+          // Extract error summary
+          const errors = result.stdout
+            .split("\n")
+            .filter((line) => line.includes("error TS"))
+            .slice(0, 5) // Show max 5 errors
+            .join("\n");
+
+          if (errors) {
+            // Send validation errors as a message to the agent
+            pi.sendMessage(
+              {
+                customType: "dcl-validation",
+                content: `TypeScript validation errors detected:\n\`\`\`\n${errors}\n\`\`\`\nPlease fix these type errors.`,
+                display: `TypeScript errors found in ${filePath}`,
+              },
+              { triggerTurn: false, deliverAs: "nextTurn" }
+            );
+          }
+        }
+      } catch {
+        // Validation timed out or failed — don't block the user
+      }
+    }, 500);
+  });
+};
+
+export default extension;