@gethmy/mcp 2.11.2 → 2.13.0

package/dist/lib/api-client.js

@@ -944,6 +944,9 @@ var TIMINGS = {
   QUERY_STALE_TIME: 1000 * 60 * 5,
   QUERY_GC_TIME: 1000 * 60 * 60 * 24
 };
+// ../harmony-shared/dist/stageHandoff.js
+var HANDOFF_MARKER = "harmony:stage-handoff";
+var HANDOFF_BLOCK_RE = new RegExp("```json\\s*\\n//\\s*" + HANDOFF_MARKER + "\\s*\\n([\\s\\S]*?)\\n```", "m");
 // src/api-client.ts
 init_config();
 var RETRY_CONFIG = {
@@ -1303,9 +1306,29 @@ class HarmonyApiClient {
   async uploadCardAttachment(cardId, data) {
     return this.request("POST", `/cards/${cardId}/attachments`, data);
   }
+  async requestCardAttachmentUploadUrl(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/attachment-upload-url`, data);
+  }
+  async finalizeCardAttachment(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/attachments/finalize`, data);
+  }
   async getCardExternalLinks(cardId) {
     return this.request("GET", `/cards/${cardId}/external-links`);
   }
+  async uploadArtifact(data) {
+    return this.request("POST", "/artifacts", data);
+  }
+  async requestArtifactUploadUrl(data) {
+    return this.request("POST", "/artifacts/upload-url", data);
+  }
+  async finalizeArtifact(data) {
+    return this.request("POST", "/artifacts/finalize", data);
+  }
+  async createArtifactShareLink(artifactId, expiresAt) {
+    return this.request("POST", `/artifacts/${artifactId}/share`, {
+      expires_at: expiresAt
+    });
+  }
   async classifyCard(cardId) {
     return this.request("POST", `/cards/${cardId}/classify`);
   }
@@ -1772,6 +1795,30 @@ ${planContent.trim()}`;
       title: cardData.title
     };
   }
+  async listPlaybooks(workspaceId) {
+    return this.request("GET", `/playbooks?workspaceId=${encodeURIComponent(workspaceId)}`);
+  }
+  async getPlaybook(playbookId) {
+    return this.request("GET", `/playbooks/${playbookId}`);
+  }
+  async getPlaybookVersion(playbookId, version) {
+    return this.request("GET", `/playbooks/${encodeURIComponent(playbookId)}/versions/${version}`);
+  }
+  async recordStageGateEvidence(insert) {
+    return this.request("POST", `/cards/${encodeURIComponent(insert.card_id)}/stage-gate-evidence`, insert);
+  }
+  async createPlaybook(data) {
+    return this.request("POST", "/playbooks", data);
+  }
+  async updatePlaybook(playbookId, updates) {
+    return this.request("PATCH", `/playbooks/${playbookId}`, updates);
+  }
+  async runPlaybook(playbookId) {
+    return this.request("POST", `/playbooks/${playbookId}/run`);
+  }
+  async savePlaybookFromCard(data) {
+    return this.request("POST", "/playbooks/from-card", data);
+  }
 }
 var _promptModules = null;
 async function loadPromptModules() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "2.11.2",
+  "version": "2.13.0",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"

package/src/api-client.ts

@@ -2,6 +2,9 @@ import {
   type AgentRunEventDraft,
   type Comment,
   getDisplayLinkType,
+  type PlaybookVersionDef,
+  type StageGateEvidenceInsert,
+  type StageGateEvidenceRow,
   serializeCommentThread,
   type WorkspaceAgent,
 } from "@harmony/shared";
@@ -143,6 +146,15 @@ export interface CardAttachment {
   signed_url_expires_in: number;
 }
 
+/** Response of a `*-upload-url` endpoint: a one-shot signed Supabase Storage
+ * URL the caller PUTs raw bytes to, plus the service-chosen path that the
+ * matching `finalize` call validates and registers. */
+export interface SignedUpload {
+  uploadUrl: string;
+  token: string;
+  storagePath: string;
+}
+
 export interface CardExternalLinkRow {
   id: string;
   card_id: string;
@@ -675,12 +687,89 @@ export class HarmonyApiClient {
     return this.request("POST", `/cards/${cardId}/attachments`, data);
   }
 
+  // Step 1 of the direct-to-storage attachment handshake: mint a signed upload
+  // URL for a server-chosen path under the card. The caller PUTs raw bytes to
+  // `uploadUrl`, then calls finalizeCardAttachment with the returned storagePath.
+  async requestCardAttachmentUploadUrl(
+    cardId: string,
+    data: { fileName: string; fileType?: string; size: number },
+  ): Promise<SignedUpload & { fileType: string }> {
+    return this.request("POST", `/cards/${cardId}/attachment-upload-url`, data);
+  }
+
+  // Step 2: validate the uploaded object (size + magic-byte content-type +
+  // optional sha256) and insert the attachment row. The server deletes the
+  // object and rejects on any mismatch.
+  async finalizeCardAttachment(
+    cardId: string,
+    data: {
+      storagePath: string;
+      fileName: string;
+      fileType?: string;
+      sha256?: string;
+      size?: number;
+    },
+  ): Promise<{ attachment: CardAttachment }> {
+    return this.request("POST", `/cards/${cardId}/attachments/finalize`, data);
+  }
+
   async getCardExternalLinks(
     cardId: string,
   ): Promise<{ external_links: CardExternalLinkRow[] }> {
     return this.request("GET", `/cards/${cardId}/external-links`);
   }
 
+  // ============ ARTIFACTS (hosted HTML documents) ============
+
+  async uploadArtifact(data: {
+    title?: string;
+    cardId?: string;
+    planId?: string;
+    workspaceId?: string;
+    contentType?: string;
+    data: string;
+  }): Promise<{ artifact: Record<string, unknown> }> {
+    return this.request("POST", "/artifacts", data);
+  }
+
+  // Step 1 of the direct-to-storage artifact handshake: mint a signed upload
+  // URL for a server-chosen path. The caller PUTs raw HTML bytes to `uploadUrl`,
+  // then calls finalizeArtifact with the returned storagePath.
+  async requestArtifactUploadUrl(data: {
+    title?: string;
+    cardId?: string;
+    planId?: string;
+    workspaceId?: string;
+    contentType?: string;
+    size?: number;
+  }): Promise<SignedUpload> {
+    return this.request("POST", "/artifacts/upload-url", data);
+  }
+
+  // Step 2: validate the uploaded object (size + HTML magic-byte sniff +
+  // optional sha256) and insert the artifact row. The server deletes the
+  // object and rejects on any mismatch.
+  async finalizeArtifact(data: {
+    storagePath: string;
+    sha256?: string;
+    size?: number;
+    title?: string;
+    cardId?: string;
+    planId?: string;
+    workspaceId?: string;
+  }): Promise<{ artifact: Record<string, unknown> }> {
+    return this.request("POST", "/artifacts/finalize", data);
+  }
+
+  async createArtifactShareLink(
+    artifactId: string,
+    expiresAt?: string,
+  ): Promise<{ link: Record<string, unknown> }> {
+    return this.request("POST", `/artifacts/${artifactId}/share`, {
+      expires_at: expiresAt,
+    });
+  }
+
   async classifyCard(
     cardId: string,
   ): Promise<{ classification: CardClassificationResult }> {
@@ -1709,6 +1798,90 @@ export class HarmonyApiClient {
       title: cardData.title,
     };
   }
+
+  // ============ PLAYBOOKS (Method/Loop layer) ============
+
+  async listPlaybooks(workspaceId: string): Promise<{ playbooks: unknown[] }> {
+    return this.request(
+      "GET",
+      `/playbooks?workspaceId=${encodeURIComponent(workspaceId)}`,
+    );
+  }
+
+  async getPlaybook(
+    playbookId: string,
+  ): Promise<{ playbook: unknown; runs: unknown[] }> {
+    return this.request("GET", `/playbooks/${playbookId}`);
+  }
+
+  /**
+   * Fetch the pinned, immutable stage-def snapshot for `(playbookId, version)`.
+   * The agent daemon's stage executor (#514) resolves a card's `current_stage`
+   * against this frozen def — never live `playbooks.steps` — so editing a
+   * Playbook never rewrites an in-flight card.
+   */
+  async getPlaybookVersion(
+    playbookId: string,
+    version: number,
+  ): Promise<{
+    version: PlaybookVersionDef & { playbook_id: string; version: number };
+  }> {
+    return this.request(
+      "GET",
+      `/playbooks/${encodeURIComponent(playbookId)}/versions/${version}`,
+    );
+  }
+
+  /**
+   * Persist a stage gate evidence row (Playbooks P1 #3, card #516). The daemon
+   * collects + evaluates a gate then POSTs the resulting evidence here; the edge
+   * writes it with the service-role client (the table has no INSERT RLS policy,
+   * so this is the only write path). Returns the inserted row.
+   */
+  async recordStageGateEvidence(
+    insert: StageGateEvidenceInsert,
+  ): Promise<{ evidence: StageGateEvidenceRow }> {
+    return this.request(
+      "POST",
+      `/cards/${encodeURIComponent(insert.card_id)}/stage-gate-evidence`,
+      insert,
+    );
+  }
+
+  async createPlaybook(data: {
+    workspaceId: string;
+    name: string;
+    description?: string;
+    steps?: unknown;
+    stepsVersion?: number;
+    triggerType?: string;
+  }): Promise<{ playbook: unknown }> {
+    return this.request("POST", "/playbooks", data);
+  }
+
+  async updatePlaybook(
+    playbookId: string,
+    updates: {
+      name?: string;
+      description?: string;
+      steps?: unknown;
+      enabled?: boolean;
+      state?: string;
+    },
+  ): Promise<{ playbook: unknown }> {
+    return this.request("PATCH", `/playbooks/${playbookId}`, updates);
+  }
+
+  async runPlaybook(playbookId: string): Promise<{ run: unknown }> {
+    return this.request("POST", `/playbooks/${playbookId}/run`);
+  }
+
+  async savePlaybookFromCard(data: {
+    cardId: string;
+    name?: string;
+  }): Promise<{ playbook: unknown }> {
+    return this.request("POST", "/playbooks/from-card", data);
+  }
 }
 
 // Shared types for generateCardPrompt to avoid inline assertions