create-stylus-ide 1.0.0

package/frontend/lib/deployment.ts

@@ -0,0 +1,176 @@
+// deployment.ts
+import { spawn } from "child_process";
+import { COMPILATION_CONSTANTS } from "./constants";
+import type { CompilationOutput } from "./compilation";
+
+export interface DeploymentResult {
+  success: boolean;
+  contractAddress?: string;
+  deploymentTxHash?: string;
+  activationTxHash?: string;
+  rpcUsed?: string;
+  error?: string;
+  output: CompilationOutput[];
+}
+
+function stripAnsi(input: string) {
+  return input.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+function extractDeployInfo(allText: string) {
+  const text = stripAnsi(allText);
+
+  const addr =
+    text.match(/deployed code at address:\s*(0x[a-fA-F0-9]{40})/i)?.[1] ??
+    text.match(/contract address:\s*(0x[a-fA-F0-9]{40})/i)?.[1] ??
+    text.match(/activated at address:\s*(0x[a-fA-F0-9]{40})/i)?.[1];
+
+  const deploymentTx =
+    text.match(/deployment tx hash:\s*(0x[a-fA-F0-9]{64})/i)?.[1] ??
+    text.match(/deployment transaction hash:\s*(0x[a-fA-F0-9]{64})/i)?.[1];
+
+  const activationTx =
+    text.match(/contract activated.*tx hash:\s*(0x[a-fA-F0-9]{64})/i)?.[1] ??
+    text.match(/wasm already activated.*(0x[a-fA-F0-9]{64})/i)?.[1];
+
+  // fallback: first 64-byte hash we can find
+  const anyHash = text.match(/0x[a-fA-F0-9]{64}/)?.[0];
+
+  return {
+    contractAddress: addr,
+    deploymentTxHash: deploymentTx ?? anyHash,
+    activationTxHash: activationTx,
+  };
+}
+
+export async function deployContract(
+  projectPath: string,
+  privateKey: string,
+  rpcUrl: string,
+  onOutput?: (output: CompilationOutput) => void
+): Promise<DeploymentResult> {
+  return new Promise((resolve) => {
+    const output: CompilationOutput[] = [];
+    const startTime = Date.now();
+
+    let stdoutBuf = "";
+    let stderrBuf = "";
+
+    const args = [
+      "stylus",
+      "deploy",
+      "--private-key",
+      privateKey,
+      "--endpoint",
+      rpcUrl,
+      "--no-verify",
+      "--max-fee-per-gas-gwei",
+      "0.5",
+    ];
+
+    const proc = spawn("cargo", args, {
+      cwd: projectPath,
+      shell: false,
+      env: {
+        ...process.env,
+        // ✅ critical: makes parsing stable
+        CARGO_TERM_COLOR: "never",
+        RUST_LOG: "info",
+      },
+    });
+
+    const timeout = setTimeout(() => {
+      proc.kill();
+      const msg: CompilationOutput = {
+        type: "error",
+        data: "Deployment timed out after 3 minutes",
+        timestamp: Date.now() - startTime,
+      };
+      output.push(msg);
+      onOutput?.(msg);
+      resolve({
+        success: false,
+        error: "Deployment timeout",
+        output,
+        rpcUsed: rpcUrl,
+      });
+    }, COMPILATION_CONSTANTS.PROCESS_TIMEOUT);
+
+    proc.stdout.on("data", (data) => {
+      const text = data.toString();
+      stdoutBuf += text;
+
+      const msg: CompilationOutput = {
+        type: "stdout",
+        data: text,
+        timestamp: Date.now() - startTime,
+      };
+      output.push(msg);
+      onOutput?.(msg);
+    });
+
+    proc.stderr.on("data", (data) => {
+      const text = data.toString();
+      stderrBuf += text;
+
+      const msg: CompilationOutput = {
+        type: "stderr",
+        data: text,
+        timestamp: Date.now() - startTime,
+      };
+      output.push(msg);
+      onOutput?.(msg);
+    });
+
+    proc.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve({
+        success: false,
+        error: error.message,
+        output,
+        rpcUsed: rpcUrl,
+      });
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+
+      const combined = stdoutBuf + "\n" + stderrBuf;
+      const { contractAddress, deploymentTxHash, activationTxHash } =
+        extractDeployInfo(combined);
+
+      if (code === 0 && contractAddress) {
+        resolve({
+          success: true,
+          contractAddress,
+          deploymentTxHash,
+          activationTxHash,
+          output,
+          rpcUsed: rpcUrl,
+        });
+        return;
+      }
+
+      // ✅ handle "success but nonzero exit" (rare) if address exists
+      if (contractAddress) {
+        resolve({
+          success: true,
+          contractAddress,
+          deploymentTxHash,
+          activationTxHash,
+          output,
+          rpcUsed: rpcUrl,
+          error: `Non-zero exit code ${code}, but contract address was found.`,
+        });
+        return;
+      }
+
+      resolve({
+        success: false,
+        error: stripAnsi(stderrBuf || "Deployment failed"),
+        output,
+        rpcUsed: rpcUrl,
+      });
+    });
+  });
+}

package/frontend/lib/file-utils.ts

@@ -0,0 +1,83 @@
+import fs from "fs/promises";
+import path from "path";
+import { COMPILATION_CONSTANTS } from "./constants";
+
+export async function createProjectStructure(projectPath: string) {
+  const srcPath = path.join(projectPath, "src");
+  await fs.mkdir(srcPath, { recursive: true });
+  return { projectPath, srcPath };
+}
+
+export async function writeProjectFiles(
+  projectPath: string,
+  srcPath: string,
+  code: string,
+  cargoToml: string,
+  rustToolchain: string,
+  mainRs: string,
+  gitignore: string
+) {
+  await Promise.all([
+    fs.writeFile(path.join(projectPath, "Cargo.toml"), cargoToml),
+    fs.writeFile(path.join(projectPath, "rust-toolchain.toml"), rustToolchain),
+    fs.writeFile(path.join(srcPath, "lib.rs"), code),
+    fs.writeFile(path.join(srcPath, "main.rs"), mainRs),
+    fs.writeFile(path.join(projectPath, ".gitignore"), gitignore),
+  ]);
+}
+
+export async function cleanupProject(sessionId: string) {
+  const projectPath = path.join(
+    process.cwd(),
+    COMPILATION_CONSTANTS.TEMP_BASE,
+    sessionId
+  );
+  try {
+    await fs.rm(projectPath, { recursive: true, force: true });
+  } catch (error) {
+    console.error("Cleanup error:", error);
+  }
+}
+
+export async function cleanupOldProjects(maxAgeMinutes: number = 30) {
+  const tempBase = path.join(process.cwd(), COMPILATION_CONSTANTS.TEMP_BASE);
+
+  try {
+    const entries = await fs.readdir(tempBase, { withFileTypes: true });
+    const now = Date.now();
+    const maxAgeMs = maxAgeMinutes * 60 * 1000;
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const projectPath = path.join(tempBase, entry.name);
+        try {
+          const stats = await fs.stat(projectPath);
+          const age = now - stats.mtimeMs;
+
+          if (age > maxAgeMs) {
+            await fs.rm(projectPath, { recursive: true, force: true });
+            console.log(`Cleaned up old project: ${entry.name}`);
+          }
+        } catch {
+          // ignore per-project errors
+        }
+      }
+    }
+  } catch {
+    // ignore if temp directory doesn't exist
+  }
+}
+
+export function getProjectPath(sessionId: string): string {
+  return path.join(process.cwd(), COMPILATION_CONSTANTS.TEMP_BASE, sessionId);
+}
+
+export async function projectExists(sessionId: string): Promise<boolean> {
+  const projectPath = getProjectPath(sessionId);
+  try {
+    await fs.access(projectPath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/frontend/lib/github-api.ts

@@ -0,0 +1,246 @@
+/**
+ * GitHub API client for fetching repository contents
+ */
+
+import {
+  GitHubTree,
+  GitHubContent,
+  GitHubRepo,
+  GitHubError,
+} from "@/types/github";
+
+const GITHUB_API_BASE = "https://api.github.com";
+const GITHUB_RAW_BASE = "https://raw.githubusercontent.com";
+
+export class GitHubAPIError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public isRateLimit: boolean = false,
+    public isNotFound: boolean = false,
+    public isForbidden: boolean = false,
+    public resetAt?: Date
+  ) {
+    super(message);
+    this.name = "GitHubAPIError";
+  }
+}
+
+/**
+ * GitHub API client with rate limit handling
+ */
+export class GitHubAPIClient {
+  private rateLimitRemaining: number | null = null;
+  private rateLimitReset: number | null = null;
+
+  /**
+   * Fetch repository information
+   */
+  async getRepo(owner: string, repo: string): Promise<GitHubRepo> {
+    const url = `${GITHUB_API_BASE}/repos/${owner}/${repo}`;
+    return this.fetchJSON<GitHubRepo>(url);
+  }
+
+  /**
+   * Fetch repository tree (all files recursively)
+   */
+  async getRepoTree(
+    owner: string,
+    repo: string,
+    branch: string = "main"
+  ): Promise<GitHubTree> {
+    const url = `${GITHUB_API_BASE}/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+    return this.fetchJSON<GitHubTree>(url);
+  }
+
+  /**
+   * Fetch file content (returns base64 encoded content)
+   */
+  async getFileContent(
+    owner: string,
+    repo: string,
+    path: string,
+    branch?: string
+  ): Promise<GitHubContent> {
+    let url = `${GITHUB_API_BASE}/repos/${owner}/${repo}/contents/${path}`;
+    if (branch) {
+      url += `?ref=${branch}`;
+    }
+    return this.fetchJSON<GitHubContent>(url);
+  }
+
+  /**
+   * Fetch raw file content (direct text)
+   */
+  async getRawFileContent(
+    owner: string,
+    repo: string,
+    path: string,
+    branch: string = "main"
+  ): Promise<string> {
+    const url = `${GITHUB_RAW_BASE}/${owner}/${repo}/${branch}/${path}`;
+
+    try {
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          throw new GitHubAPIError(`File not found: ${path}`, 404, false, true);
+        }
+        throw new GitHubAPIError(
+          `Failed to fetch file: ${response.statusText}`,
+          response.status
+        );
+      }
+
+      return response.text();
+    } catch (error) {
+      if (error instanceof GitHubAPIError) {
+        throw error;
+      }
+
+      // Network error
+      throw new GitHubAPIError(
+        "Network error. Please check your connection and try again.",
+        0
+      );
+    }
+  }
+
+  /**
+   * Get default branch for repository
+   */
+  async getDefaultBranch(owner: string, repo: string): Promise<string> {
+    const repo_info = await this.getRepo(owner, repo);
+    return repo_info.default_branch;
+  }
+
+  /**
+   * Check if branch exists
+   */
+  async branchExists(
+    owner: string,
+    repo: string,
+    branch: string
+  ): Promise<boolean> {
+    try {
+      await this.getRepoTree(owner, repo, branch);
+      return true;
+    } catch (error) {
+      if (error instanceof GitHubAPIError && error.isNotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Generic JSON fetch with error handling
+   */
+  private async fetchJSON<T>(url: string): Promise<T> {
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          // Add GitHub token if available (increases rate limit)
+          ...(process.env.NEXT_PUBLIC_GITHUB_TOKEN && {
+            Authorization: `token ${process.env.NEXT_PUBLIC_GITHUB_TOKEN}`,
+          }),
+        },
+      });
+
+      // Update rate limit info
+      this.updateRateLimitInfo(response);
+
+      if (!response.ok) {
+        const error: GitHubError = await response.json().catch(() => ({
+          message: response.statusText,
+        }));
+
+        // Handle specific error cases
+        if (response.status === 404) {
+          throw new GitHubAPIError(
+            "Repository not found. Please check the URL and try again.",
+            404,
+            false,
+            true
+          );
+        } else if (response.status === 403) {
+          // Check if it's rate limit or forbidden
+          if (this.rateLimitRemaining === 0) {
+            const resetDate = this.rateLimitReset
+              ? new Date(this.rateLimitReset)
+              : undefined;
+            throw new GitHubAPIError(
+              "GitHub API rate limit exceeded. Please try again later or add a GitHub token.",
+              403,
+              true,
+              false,
+              false,
+              resetDate
+            );
+          } else {
+            throw new GitHubAPIError(
+              "Access forbidden. This repository may be private or require authentication.",
+              403,
+              false,
+              false,
+              true
+            );
+          }
+        } else if (response.status === 401) {
+          throw new GitHubAPIError(
+            "Authentication failed. Please check your GitHub token.",
+            401
+          );
+        } else if (response.status >= 500) {
+          throw new GitHubAPIError(
+            "GitHub is experiencing issues. Please try again later.",
+            response.status
+          );
+        } else {
+          throw new GitHubAPIError(
+            error.message || "Failed to fetch from GitHub",
+            response.status
+          );
+        }
+      }
+
+      return response.json();
+    } catch (error) {
+      if (error instanceof GitHubAPIError) {
+        throw error;
+      }
+
+      // Network error or JSON parse error
+      throw new GitHubAPIError(
+        "Network error. Please check your connection and try again.",
+        0
+      );
+    }
+  }
+
+  /**
+   * Update rate limit tracking from response headers
+   */
+  private updateRateLimitInfo(response: Response): void {
+    const remaining = response.headers.get("X-RateLimit-Remaining");
+    const reset = response.headers.get("X-RateLimit-Reset");
+
+    if (remaining) this.rateLimitRemaining = parseInt(remaining, 10);
+    if (reset) this.rateLimitReset = parseInt(reset, 10) * 1000; // Convert to ms
+  }
+
+  /**
+   * Get current rate limit status
+   */
+  getRateLimitStatus(): { remaining: number | null; resetAt: Date | null } {
+    return {
+      remaining: this.rateLimitRemaining,
+      resetAt: this.rateLimitReset ? new Date(this.rateLimitReset) : null,
+    };
+  }
+}
+
+// Export singleton instance
+export const githubAPI = new GitHubAPIClient();