staklink 0.3.5 → 0.3.7

package/dist/proxy-server.cjs

@@ -33901,7 +33901,7 @@ var SSEManager = class {
 var sseManager = new SSEManager();
 
 // src/proxy/version.ts
-var VERSION = "0.3.5";
+var VERSION = "0.3.7";
 
 // node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
@@ -79579,6 +79579,387 @@ function gitleaksProtect() {
   }
 }
 
+// src/proxy/gh.ts
+var import_child_process4 = require("child_process");
+var import_util10 = require("util");
+var execAsync = (0, import_util10.promisify)(import_child_process4.exec);
+var GitHubCLI = class {
+  token;
+  branch;
+  owner;
+  repo;
+  constructor(token, branch) {
+    this.token = token;
+    this.branch = branch;
+  }
+  /**
+   * Initialize and get repo info from git
+   */
+  async init() {
+    try {
+      const { stdout } = await this.execGH("repo view --json owner,name");
+      const data = JSON.parse(stdout);
+      this.owner = data.owner.login;
+      this.repo = data.name;
+    } catch (error82) {
+      throw new Error(`Failed to initialize: ${error82}`);
+    }
+  }
+  /**
+   * Execute gh CLI command with authentication
+   */
+  async execGH(command) {
+    const fullCommand = `gh ${command}`;
+    try {
+      return await execAsync(fullCommand, {
+        env: {
+          ...process.env,
+          GH_TOKEN: this.token,
+          GITHUB_TOKEN: this.token
+        }
+      });
+    } catch (error82) {
+      throw new Error(
+        `gh command failed: ${error82.message}
+Stderr: ${error82.stderr}`
+      );
+    }
+  }
+  /**
+   * Sync version of execGH for simple checks
+   */
+  execGHSync(command) {
+    const fullCommand = `gh ${command}`;
+    try {
+      return (0, import_child_process4.execSync)(fullCommand, {
+        encoding: "utf-8",
+        env: {
+          ...process.env,
+          GH_TOKEN: this.token,
+          GITHUB_TOKEN: this.token
+        }
+      });
+    } catch (error82) {
+      throw new Error(
+        `gh command failed: ${error82.message}
+Stderr: ${error82.stderr}`
+      );
+    }
+  }
+  /**
+   * Check if the branch exists
+   */
+  async branchExists() {
+    try {
+      const { stdout } = await execAsync(
+        "git rev-parse --verify --quiet " + this.branch
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get current branch name
+   */
+  async getCurrentBranch() {
+    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD");
+    return stdout.trim();
+  }
+  /**
+   * Checkout the branch
+   */
+  async checkoutBranch() {
+    try {
+      await execAsync(`git checkout ${this.branch}`);
+    } catch (error82) {
+      throw new Error(`Failed to checkout branch ${this.branch}: ${error82}`);
+    }
+  }
+  /**
+   * Create a new PR from the branch
+   */
+  async createPR(options) {
+    const args = [
+      "pr",
+      "create",
+      "--head",
+      this.branch,
+      "--title",
+      `"${options.title}"`
+    ];
+    if (options.body) {
+      args.push("--body", `"${options.body}"`);
+    }
+    if (options.base) {
+      args.push("--base", options.base);
+    }
+    if (options.draft) {
+      args.push("--draft");
+    }
+    if (options.assignees?.length) {
+      args.push("--assignee", options.assignees.join(","));
+    }
+    if (options.reviewers?.length) {
+      args.push("--reviewer", options.reviewers.join(","));
+    }
+    if (options.labels?.length) {
+      args.push("--label", options.labels.join(","));
+    }
+    try {
+      const { stdout } = await this.execGH(args.join(" "));
+      const prUrl = stdout.trim();
+      const prNumber = parseInt(prUrl.split("/").pop() || "0");
+      return await this.getPR(prNumber);
+    } catch (error82) {
+      throw new Error(`Failed to create PR: ${error82}`);
+    }
+  }
+  /**
+   * Find PR by branch name
+   */
+  async findPRByBranch() {
+    try {
+      const { stdout } = await this.execGH(
+        `pr list --head ${this.branch} --json number,title,body,state,url,headRefName,baseRefName,mergeable,mergeStateStatus,isDraft,author,createdAt,updatedAt --limit 1`
+      );
+      const prs = JSON.parse(stdout);
+      if (prs.length === 0) {
+        return null;
+      }
+      const pr = prs[0];
+      return {
+        number: pr.number,
+        title: pr.title,
+        body: pr.body,
+        state: pr.state,
+        url: pr.url,
+        headRefName: pr.headRefName,
+        baseRefName: pr.baseRefName,
+        mergeable: pr.mergeable,
+        mergeStateStatus: pr.mergeStateStatus,
+        isDraft: pr.isDraft,
+        author: pr.author.login,
+        createdAt: pr.createdAt,
+        updatedAt: pr.updatedAt
+      };
+    } catch (error82) {
+      throw new Error(`Failed to find PR: ${error82}`);
+    }
+  }
+  /**
+   * Get PR details by number
+   */
+  async getPR(prNumber) {
+    try {
+      const { stdout } = await this.execGH(
+        `pr view ${prNumber} --json number,title,body,state,url,headRefName,baseRefName,mergeable,mergeStateStatus,isDraft,author,createdAt,updatedAt`
+      );
+      const pr = JSON.parse(stdout);
+      return {
+        number: pr.number,
+        title: pr.title,
+        body: pr.body,
+        state: pr.state,
+        url: pr.url,
+        headRefName: pr.headRefName,
+        baseRefName: pr.baseRefName,
+        mergeable: pr.mergeable,
+        mergeStateStatus: pr.mergeStateStatus,
+        isDraft: pr.isDraft,
+        author: pr.author.login,
+        createdAt: pr.createdAt,
+        updatedAt: pr.updatedAt
+      };
+    } catch (error82) {
+      throw new Error(`Failed to get PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Check if PR is auto-mergeable
+   */
+  async isPRMergeable(prNumber) {
+    const pr = await this.getPR(prNumber);
+    const isMergeable = pr.mergeable === "MERGEABLE" && pr.mergeStateStatus === "CLEAN" && pr.state === "OPEN" && !pr.isDraft;
+    let reason;
+    if (!isMergeable) {
+      if (pr.isDraft) {
+        reason = "PR is in draft state";
+      } else if (pr.mergeable === "CONFLICTING") {
+        reason = "PR has merge conflicts";
+      } else if (pr.mergeStateStatus === "BLOCKED") {
+        reason = "PR is blocked by required checks";
+      } else if (pr.mergeStateStatus === "BEHIND") {
+        reason = "Branch is behind base branch";
+      } else if (pr.mergeStateStatus === "UNSTABLE") {
+        reason = "Some checks are failing";
+      } else if (pr.mergeable === "UNKNOWN") {
+        reason = "Mergeability is still being calculated";
+      } else {
+        reason = `Status: ${pr.mergeStateStatus}`;
+      }
+    }
+    return { mergeable: isMergeable, reason };
+  }
+  /**
+   * Merge a PR
+   */
+  async mergePR(prNumber, options) {
+    const {
+      method = "squash",
+      deleteBranch = true,
+      auto = false,
+      commitTitle,
+      commitBody
+    } = options || {};
+    const args = ["pr", "merge", prNumber.toString()];
+    if (auto) {
+      args.push("--auto");
+    }
+    switch (method) {
+      case "squash":
+        args.push("--squash");
+        break;
+      case "rebase":
+        args.push("--rebase");
+        break;
+      case "merge":
+        args.push("--merge");
+        break;
+    }
+    if (deleteBranch) {
+      args.push("--delete-branch");
+    }
+    if (commitTitle) {
+      args.push("--subject", `"${commitTitle}"`);
+    }
+    if (commitBody) {
+      args.push("--body", `"${commitBody}"`);
+    }
+    try {
+      const { stdout } = await this.execGH(args.join(" "));
+      console.log(stdout);
+    } catch (error82) {
+      throw new Error(`Failed to merge PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Check if PR is mergeable and merge if ready
+   */
+  async checkAndMerge(prNumber, options) {
+    const { mergeable, reason } = await this.isPRMergeable(prNumber);
+    if (!mergeable) {
+      console.log(`PR #${prNumber} is not mergeable: ${reason}`);
+      return false;
+    }
+    await this.mergePR(prNumber, options);
+    return true;
+  }
+  /**
+   * Wait for PR to be mergeable and then merge
+   */
+  async waitAndMerge(prNumber, options) {
+    const {
+      maxWaitTime = 3e5,
+      // 5 minutes
+      checkInterval = 1e4,
+      // 10 seconds
+      ...mergeOptions
+    } = options || {};
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTime) {
+      const { mergeable, reason } = await this.isPRMergeable(prNumber);
+      if (mergeable) {
+        await this.mergePR(prNumber, mergeOptions);
+        return true;
+      }
+      if (reason?.includes("conflict")) {
+        throw new Error(`PR #${prNumber} has merge conflicts`);
+      }
+      console.log(`Waiting for PR #${prNumber} to be mergeable... (${reason})`);
+      await new Promise((resolve3) => setTimeout(resolve3, checkInterval));
+    }
+    throw new Error(
+      `Timeout: PR #${prNumber} did not become mergeable within ${maxWaitTime}ms`
+    );
+  }
+  /**
+   * Add comment to PR
+   */
+  async addComment(prNumber, comment) {
+    try {
+      await this.execGH(`pr comment ${prNumber} --body "${comment}"`);
+    } catch (error82) {
+      throw new Error(`Failed to add comment to PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Update PR title and/or body
+   */
+  async updatePR(prNumber, updates) {
+    const args = ["pr", "edit", prNumber.toString()];
+    if (updates.title) {
+      args.push("--title", `"${updates.title}"`);
+    }
+    if (updates.body) {
+      args.push("--body", `"${updates.body}"`);
+    }
+    try {
+      await this.execGH(args.join(" "));
+    } catch (error82) {
+      throw new Error(`Failed to update PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Close PR
+   */
+  async closePR(prNumber, comment) {
+    try {
+      if (comment) {
+        await this.addComment(prNumber, comment);
+      }
+      await this.execGH(`pr close ${prNumber}`);
+    } catch (error82) {
+      throw new Error(`Failed to close PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Reopen PR
+   */
+  async reopenPR(prNumber) {
+    try {
+      await this.execGH(`pr reopen ${prNumber}`);
+    } catch (error82) {
+      throw new Error(`Failed to reopen PR #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Get PR checks status
+   */
+  async getPRChecks(prNumber) {
+    try {
+      const { stdout } = await this.execGH(
+        `pr checks ${prNumber} --json name,state,conclusion`
+      );
+      return JSON.parse(stdout);
+    } catch (error82) {
+      throw new Error(`Failed to get PR checks for #${prNumber}: ${error82}`);
+    }
+  }
+  /**
+   * Get repo info
+   */
+  getRepoInfo() {
+    return { owner: this.owner, repo: this.repo };
+  }
+  /**
+   * Get branch name
+   */
+  getBranch() {
+    return this.branch;
+  }
+};
+
 // src/proxy/server.ts
 var PORT = parseInt(process.env.STAKLINK_PORT || "15552") || 15552;
 var VSCODE_EXTENSION_URL = `http://localhost:${PORT + 1}`;
@@ -79898,7 +80279,13 @@ async function startProxyServer() {
       console.log(`===> POST /push`);
       const code = req.body;
       const repos = getReposWithChangedFiles(code);
+      const createPR = req.query.pr === "true";
       const commits = [];
+      const prs = {};
+      console.log(`=> PR creation requested: ${createPR}`);
+      console.log(
+        `=> Git credentials available: ${!!code.git_credentials?.auth_data?.token}`
+      );
       for (const r of repos) {
         console.log(`=> PUSH to ${r.url}`);
         const repo = await NewRepo(r.url);
@@ -79909,8 +80296,47 @@ async function startProxyServer() {
         }
         const link = await repo.getLatestCommitLink();
         commits.push(link);
+        if (createPR) {
+          const repoName = getRepoNameFromUrl(r.url);
+          if (!code.git_credentials?.auth_data?.token) {
+            console.error(`=> No GitHub token available for PR creation`);
+            prs[repoName] = "Error: GitHub token required for PR creation";
+            continue;
+          }
+          try {
+            console.log(`=> Creating PR for ${r.url}`);
+            console.log(`=> Branch: ${r.branch_name}`);
+            console.log(`=> Base: ${r.base_branch || "main"}`);
+            const gh = new GitHubCLI(
+              code.git_credentials.auth_data.token,
+              r.branch_name
+            );
+            await gh.init();
+            const existingPR = await gh.findPRByBranch();
+            if (existingPR) {
+              console.log(`=> PR already exists: ${existingPR.url}`);
+              prs[repoName] = existingPR.url;
+            } else {
+              const pr = await gh.createPR({
+                title: r.commit_name || `Changes from ${r.branch_name}`,
+                body: `Automated PR from branch ${r.branch_name}`,
+                base: r.base_branch || "main",
+                draft: false
+              });
+              console.log(`=> PR created: ${pr.url}`);
+              prs[repoName] = pr.url;
+            }
+          } catch (prError) {
+            console.error(`=> Failed to create PR for ${r.url}:`, prError);
+            prs[repoName] = `Error: ${prError instanceof Error ? prError.message : String(prError)}`;
+          }
+        }
+      }
+      const response = { success: true, commits };
+      if (createPR) {
+        response.prs = prs;
       }
-      res.json({ success: true, commits });
+      res.json(response);
     } catch (e) {
       fail(res, e);
     }

package/dist/staklink-cli.cjs

@@ -10905,7 +10905,7 @@ var glob = Object.assign(glob_, {
 glob.glob = glob;
 
 // src/proxy/version.ts
-var VERSION = "0.3.5";
+var VERSION = "0.3.7";
 
 // src/cli.ts
 var STAKLINK_PROXY = "staklink-proxy";

package/package.json

@@ -2,7 +2,7 @@
   "name": "staklink",
   "displayName": "staklink",
   "description": "staklink process manager",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "type": "module",
   "publisher": "stakwork",
   "engines": {