git-workspace-service 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -324,24 +324,28 @@ var WorkspaceService = class {
       credential = parent.credential;
     } else {
       await fs3__namespace.mkdir(workspacePath, { recursive: true });
-      credential = await this.credentialService.getCredentials({
-        repo: config.repo,
-        access: "write",
-        context: {
+      if (config.userCredentials) {
+        credential = await this.credentialService.getCredentials({
+          repo: config.repo,
+          access: "write",
+          context: {
+            executionId: config.execution.id,
+            taskId: config.task.id,
+            userId: config.user?.id,
+            reason: `Workspace for ${config.task.role} in ${config.execution.patternName}`
+          },
+          userProvided: config.userCredentials
+        });
+      }
+      if (credential) {
+        await this.emitEvent({
+          type: "credential:granted",
+          workspaceId,
+          credentialId: credential.id,
           executionId: config.execution.id,
-          taskId: config.task.id,
-          userId: config.user?.id,
-          reason: `Workspace for ${config.task.role} in ${config.execution.patternName}`
-        },
-        userProvided: config.userCredentials
-      });
-      await this.emitEvent({
-        type: "credential:granted",
-        workspaceId,
-        credentialId: credential.id,
-        executionId: config.execution.id,
-        timestamp: /* @__PURE__ */ new Date()
-      });
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
     }
     const branchInfo = createBranchInfo(
       {
@@ -358,15 +362,55 @@ var WorkspaceService = class {
       repo: config.repo,
       branch: branchInfo,
       credential,
+      // Will be set before any write operations
       provisionedAt: /* @__PURE__ */ new Date(),
       status: "provisioning",
       strategy,
-      parentWorkspaceId: config.parentWorkspace
+      parentWorkspaceId: config.parentWorkspace,
+      onComplete: config.onComplete,
+      progress: {
+        phase: "initializing",
+        message: "Initializing workspace",
+        updatedAt: /* @__PURE__ */ new Date()
+      }
     };
     this.workspaces.set(workspaceId, workspace);
     try {
       if (strategy === "clone") {
-        await this.cloneRepo(workspace, credential.token);
+        this.updateProgress(workspace, "cloning", "Cloning repository");
+        if (!credential) {
+          const cloneResult = await this.tryUnauthenticatedClone(workspace);
+          if (!cloneResult.success) {
+            this.log(
+              "info",
+              { workspaceId, error: cloneResult.error },
+              "Unauthenticated clone failed, requesting credentials"
+            );
+            credential = await this.credentialService.getCredentials({
+              repo: config.repo,
+              access: "write",
+              context: {
+                executionId: config.execution.id,
+                taskId: config.task.id,
+                userId: config.user?.id,
+                reason: `Workspace for ${config.task.role} in ${config.execution.patternName}`
+              }
+            });
+            workspace.credential = credential;
+            this.workspaces.set(workspaceId, workspace);
+            await this.emitEvent({
+              type: "credential:granted",
+              workspaceId,
+              credentialId: credential.id,
+              executionId: config.execution.id,
+              timestamp: /* @__PURE__ */ new Date()
+            });
+            await this.cloneRepo(workspace, credential.token);
+          }
+        } else {
+          await this.cloneRepo(workspace, credential.token);
+        }
+        this.updateProgress(workspace, "creating_branch", "Creating branch");
         await this.createBranch(workspace);
       } else {
         const parent = this.workspaces.get(config.parentWorkspace);
@@ -384,9 +428,12 @@ var WorkspaceService = class {
           data: { parentWorkspaceId: parent.id }
         });
       }
+      this.updateProgress(workspace, "configuring", "Configuring git");
       await this.configureGit(workspace);
       workspace.status = "ready";
+      this.updateProgress(workspace, "ready", "Workspace ready");
       this.workspaces.set(workspaceId, workspace);
+      await this.executeCompletionHook(workspace, "success");
       this.log(
         "info",
         {
@@ -406,8 +453,9 @@ var WorkspaceService = class {
       return workspace;
     } catch (error) {
       workspace.status = "error";
-      this.workspaces.set(workspaceId, workspace);
       const errorMessage = error instanceof Error ? error.message : String(error);
+      this.updateProgress(workspace, "error", errorMessage);
+      this.workspaces.set(workspaceId, workspace);
       this.log("error", { workspaceId, error: errorMessage }, "Failed to provision workspace");
       await this.emitEvent({
         type: "workspace:error",
@@ -416,6 +464,7 @@ var WorkspaceService = class {
         timestamp: /* @__PURE__ */ new Date(),
         error: errorMessage
       });
+      await this.executeCompletionHook(workspace, "error");
       throw error;
     }
   }
@@ -581,7 +630,7 @@ var WorkspaceService = class {
         });
       }
     }
-    if (workspace.strategy === "clone") {
+    if (workspace.strategy === "clone" && workspace.credential) {
       await this.credentialService.revokeCredential(workspace.credential.id);
       await this.emitEvent({
         type: "credential:revoked",
@@ -617,6 +666,36 @@ var WorkspaceService = class {
   // ─────────────────────────────────────────────────────────────
   // Private Methods
   // ─────────────────────────────────────────────────────────────
+  /**
+   * Try to clone a public repository without authentication
+   */
+  async tryUnauthenticatedClone(workspace) {
+    let cloneUrl = workspace.repo;
+    if (cloneUrl.startsWith("git@github.com:")) {
+      cloneUrl = cloneUrl.replace("git@github.com:", "https://github.com/");
+    }
+    if (!cloneUrl.endsWith(".git")) {
+      cloneUrl = `${cloneUrl}.git`;
+    }
+    if (!cloneUrl.startsWith("https://")) {
+      cloneUrl = `https://${cloneUrl}`;
+    }
+    try {
+      await this.execInDir(
+        workspace.path,
+        `git clone --depth 1 --branch ${workspace.branch.baseBranch} ${cloneUrl} .`
+      );
+      this.log("info", { workspaceId: workspace.id }, "Public repository cloned without authentication");
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isAuthError = errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("terminal prompts disabled");
+      if (isAuthError) {
+        return { success: false, error: "Authentication required" };
+      }
+      throw error;
+    }
+  }
   async cloneRepo(workspace, token) {
     const cloneUrl = token ? this.buildAuthenticatedUrl(workspace.repo, token) : workspace.repo;
     await this.execInDir(
@@ -640,11 +719,11 @@ var WorkspaceService = class {
   async configureGit(workspace) {
     await this.execInDir(workspace.path, 'git config user.name "Workspace Agent"');
     await this.execInDir(workspace.path, 'git config user.email "agent@workspace.local"');
-    if (!workspace.credential.token) {
+    if (!workspace.credential || !workspace.credential.token) {
       this.log(
         "debug",
         { workspaceId: workspace.id },
-        "Using SSH authentication, skipping credential helper"
+        workspace.credential ? "Using SSH authentication, skipping credential helper" : "No credentials (public repo), skipping credential helper"
       );
       return;
     }
@@ -670,9 +749,19 @@ var WorkspaceService = class {
     );
   }
   async pushBranch(workspace) {
+    if (!workspace.credential) {
+      throw new Error(
+        "Push requires authentication. This workspace was cloned from a public repository without credentials."
+      );
+    }
     await this.execInDir(workspace.path, `git push -u origin ${workspace.branch.name}`);
   }
   async createPullRequest(workspace, config) {
+    if (!workspace.credential) {
+      throw new Error(
+        "Pull request creation requires authentication. This workspace was cloned from a public repository without credentials."
+      );
+    }
     const repoInfo = this.parseRepo(workspace.repo);
     if (!repoInfo) {
       throw new Error(`Invalid repository format: ${workspace.repo}`);
@@ -752,6 +841,72 @@ var WorkspaceService = class {
       }
     }
   }
+  /**
+   * Update workspace progress
+   */
+  updateProgress(workspace, phase, message) {
+    workspace.progress = {
+      phase,
+      message,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.workspaces.set(workspace.id, workspace);
+    this.log(
+      "debug",
+      { workspaceId: workspace.id, phase, message },
+      "Progress updated"
+    );
+  }
+  /**
+   * Execute completion hook if configured
+   */
+  async executeCompletionHook(workspace, status) {
+    const hook = workspace.onComplete;
+    if (!hook) return;
+    if (status === "error" && hook.runOnError === false) {
+      return;
+    }
+    const env = {
+      ...process.env,
+      WORKSPACE_ID: workspace.id,
+      REPO: workspace.repo,
+      BRANCH: workspace.branch.name,
+      STATUS: status,
+      WORKSPACE_PATH: workspace.path
+    };
+    if (hook.command) {
+      try {
+        this.log("info", { workspaceId: workspace.id, command: hook.command }, "Executing completion hook command");
+        await execAsync(hook.command, { env });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log("warn", { workspaceId: workspace.id, error: errorMessage }, "Completion hook command failed");
+      }
+    }
+    if (hook.webhook) {
+      try {
+        this.log("info", { workspaceId: workspace.id, webhook: hook.webhook }, "Calling completion webhook");
+        const payload = {
+          workspaceId: workspace.id,
+          repo: workspace.repo,
+          branch: workspace.branch.name,
+          status,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await fetch(hook.webhook, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...hook.webhookHeaders
+          },
+          body: JSON.stringify(payload)
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log("warn", { workspaceId: workspace.id, error: errorMessage }, "Completion webhook failed");
+      }
+    }
+  }
 };
 
 // src/oauth/device-flow.ts