@allocator-one/harness-cli 1.5.2 → 1.7.0

package/README.md

@@ -53,7 +53,9 @@ the browser login attributes writes to the real user.
 
 `harness mcp` runs a stdio MCP server exposing every operation as a typed
 tool — issue_list, issue_show, issue_create, issue_update, issue_claim,
-issue_close, issue_comment, relation_add/rm, link_list/add/rm,
+issue_close, issue_comment, issue_comment_edit, issue_comment_delete,
+relation_list/create/update/delete, relation_add/rm (blocking shorthand),
+link_list/add/update/rm,
 project_list/show/create/update, milestone_list/create,
 document_list/show/create/update, label_list/create, team_list,
 team_create, workflow_states, user_list, stats, upload. Read-only tools carry
@@ -69,6 +71,45 @@ Example tool call: `issue_list` with `{"ready": true, "team": "ALL"}`
 returns the ready queue as JSON; `issue_claim` with `{"id": "IO-123"}`
 claims atomically (a conflict means someone else holds it).
 
+Typed issue relations are available without losing the concise blocking
+workflow. `harness dep add|rm` and the `relation_add`/`relation_rm` MCP tools
+remain the blocker-first shorthand; the full surface is:
+
+```sh
+harness relation list IO-123
+harness relation add IO-123 IO-456 --type related
+harness relation update IO-123 IO-456 --type blocks
+harness relation rm IO-123 IO-456
+```
+
+Relation update and removal accept either the relation id from `relation list`
+or a unique related issue identifier. If the same pair has more than one
+relation, the CLI refuses to guess and requires the relation id. Link updates
+use the same safe lookup rule by id or exact URL; the existing `link rm`
+command keeps its first-match behavior for backward compatibility:
+
+```sh
+harness link update IO-123 https://example.com/old --url https://example.com/new --title "Runbook"
+```
+
+Issue creation resolves `--label` names within the target team first, then at
+workspace scope. Missing names are created at workspace scope before the issue
+is filed, and the final label ids travel in the single issue-create request, so
+a preparation or permission failure cannot leave an unlabeled issue behind.
+Creating a missing label requires Harness administrator standing.
+
+Label repair is additive and repeatable; it never implicitly replaces the
+whole set:
+
+```sh
+harness update IO-123 --add-label security --add-label needs-review
+harness update IO-123 --remove-label security
+```
+
+Both update flags accept a label name or id. Additions allow only labels from
+the issue's team or workspace. Removal can target an attached legacy foreign
+label; when attached normalized names are ambiguous, use the label id.
+
 Auth resolution is identical to the CLI. Without a credential, tools return
 an error telling the agent to run `harness login` in a terminal — the
 server never opens a browser itself.

package/dist/{chunk-CIW4OU5G.js → chunk-ZHFW6PRC.js}

@@ -538,6 +538,10 @@ var STATUS_STATE_TYPES = {
 };
 var READY_CLAIM_ATTEMPTS = 10;
 var IDENTIFIER_FORMAT = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+var UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+  return UUID_FORMAT.test(value);
+}
 function requireIdentifiers(identifiers) {
   const bad = identifiers.filter((identifier) => !IDENTIFIER_FORMAT.test(identifier));
   if (bad.length > 0) {
@@ -619,7 +623,6 @@ async function version(config) {
 ` };
 }
 async function create(ctx, opts) {
-  const labels = wantedLabels(opts);
   if (opts.title === void 0) {
     throw new UsageError("usage: harness create --title <title> [--team <key>] \u2026");
   }
@@ -627,6 +630,8 @@ async function create(ctx, opts) {
   const team = requiredTeam(ctx, opts.team);
   const priority = optionalPriority(opts.priority);
   const dueDate = optionalDueDate(opts.dueDate);
+  const labels = requestedLabelNames(wantedLabels(opts));
+  const labelIds = await prepareCreateLabelIds(ctx, team, labels);
   let body = { title: opts.title };
   body = putOpt(body, "description", opts.description);
   body = putOpt(body, "design", opts.design);
@@ -636,23 +641,14 @@ async function create(ctx, opts) {
   body = putPresent(body, "priority", priority);
   body = putDueDate(body, dueDate);
   body = putAssignee(body, opts.assignee);
+  if (labelIds.length > 0) body["label_ids"] = labelIds;
   const created = await ctx.client.post(`/api/v1/teams/${team}/issues`, body);
   const issue = created.data;
-  try {
-    const labeled = await applyLabels(ctx, issue, labels);
-    return {
-      json: labeled,
-      human: `Created ${str2(labeled["identifier"])}: ${clean(labeled["title"])}
+  return {
+    json: issue,
+    human: `Created ${str2(issue["identifier"])}: ${clean(issue["title"])}
 `
-    };
-  } catch (error) {
-    if (error instanceof HttpError || error instanceof TransportError) {
-      throw new CommandError(
-        `created ${str2(issue["identifier"])}, but applying labels failed: ${errorText(error)}`
-      );
-    }
-    throw error;
-  }
+  };
 }
 async function update(ctx, identifier, opts) {
   requireIdentifiers([identifier]);
@@ -666,10 +662,15 @@ async function update(ctx, identifier, opts) {
   }
   const priority = optionalPriority(opts.priority);
   const dueDate = optionalDueDate(opts.dueDate);
-  let issue = null;
+  const addLabels = requestedLabelInputs(opts.addLabel ?? []);
+  const removeLabels = requestedLabelInputs(opts.removeLabel ?? []);
+  const labelPlan = addLabels.length > 0 || removeLabels.length > 0 ? await prepareLabelUpdate(ctx, identifier, addLabels, removeLabels) : null;
+  let issue = labelPlan?.issue ?? null;
+  let wrote = false;
   if (opts.claim === true) {
     const body = await ctx.client.post(`/api/v1/issues/${identifier}/claim`);
     issue = body.data;
+    wrote = true;
   }
   let patch = {};
   patch = putOpt(patch, "title", opts.title);
@@ -692,15 +693,26 @@ ${opts.appendNotes}`;
   if (Object.keys(patch).length > 0) {
     const body = await ctx.client.patch(`/api/v1/issues/${identifier}`, patch);
     issue = body.data;
+    wrote = true;
   }
   if (opts.state !== void 0) {
     issue = await setState(ctx, identifier, opts.state);
+    wrote = true;
+  }
+  if (labelPlan?.changed === true) {
+    const body = await ctx.client.put(`/api/v1/issues/${identifier}/labels`, {
+      label_ids: labelPlan.ids
+    });
+    issue = body.data;
+    wrote = true;
   }
   if (issue === null) {
     throw new UsageError("usage: harness update <id> --claim | --title \u2026 | --state <name> | \u2026");
   }
-  return { json: issue, human: `Updated ${str2(issue["identifier"])}
-` };
+  const human = wrote ? `Updated ${str2(issue["identifier"])}
+` : `Labels already up to date for ${str2(issue["identifier"])}
+`;
+  return { json: issue, human };
 }
 async function close(ctx, identifiers, opts) {
   if (identifiers.length === 0) {
@@ -778,8 +790,9 @@ async function comments(ctx, identifier) {
   if (body.data.length === 0) return { json: body.data, human: "No comments.\n" };
   const human = body.data.map((comment2) => {
     const author = clean((comment2["author"] ?? {})["name"] ?? "unknown");
+    const id = clean(comment2["id"] ?? "unknown id");
     const text = cleanMultiline(str2(comment2["body"])).split("\n").map((line) => "  " + line).join("\n");
-    return `[${str2(comment2["inserted_at"])}] ${author}:
+    return `[${str2(comment2["inserted_at"])}] ${author} (${id}):
 ${text}
 `;
   }).join("\n");
@@ -807,6 +820,76 @@ async function dep(ctx, verb, issue, blocker) {
   }
   throw new UsageError("usage: harness dep add|rm <issue> <blocker>  (the blocker blocks the issue)");
 }
+var RELATION_CREATE_TYPES = [
+  "blocks",
+  "blocked_by",
+  "related",
+  "duplicate",
+  "duplicate_of",
+  "duplicated_by"
+];
+var RELATION_UPDATE_TYPES = ["blocks", "blocked_by", "related", "duplicate_of"];
+function requireRelationType(type, allowed, operation) {
+  if (!allowed.includes(type)) {
+    throw new UsageError(`relation ${operation} type must be one of: ${allowed.join(", ")}`);
+  }
+}
+async function findRelation(ctx, issue, idOrIssue) {
+  const response = await ctx.client.get(`/api/v1/issues/${issue}/relations`);
+  const idMatch = response.data.find((candidate) => candidate["id"] === idOrIssue);
+  if (idMatch !== void 0) return idMatch;
+  const issueMatches = response.data.filter((candidate) => candidate["other_issue"] === idOrIssue);
+  if (issueMatches.length > 1) {
+    throw new CommandError(`multiple relations on ${issue} match ${idOrIssue}; use a relation id`);
+  }
+  if (issueMatches.length === 0) {
+    throw new CommandError(`no relation on ${issue} matches ${idOrIssue} (by id or related issue)`);
+  }
+  return issueMatches[0];
+}
+async function resolveRelationId(ctx, issue, idOrIssue) {
+  if (isUuid(idOrIssue)) return idOrIssue.toLowerCase();
+  const relation = await findRelation(ctx, issue, idOrIssue);
+  return String(relation["id"]);
+}
+async function relationList(ctx, issue) {
+  requireIdentifiers([issue]);
+  const response = await ctx.client.get(`/api/v1/issues/${issue}/relations`);
+  const human = response.data.length === 0 ? "No relations.\n" : table(
+    ["ID", "DIRECTION", "ISSUE"],
+    response.data.map((relation) => [
+      String(relation["id"] ?? ""),
+      String(relation["direction"] ?? ""),
+      String(relation["other_issue"] ?? "")
+    ])
+  );
+  return { json: response.data, human };
+}
+async function relationAdd(ctx, issue, relatedIssue, type) {
+  requireIdentifiers([issue, relatedIssue]);
+  requireRelationType(type, RELATION_CREATE_TYPES, "add");
+  const response = await ctx.client.post(`/api/v1/issues/${issue}/relations`, {
+    type,
+    related_issue: relatedIssue
+  });
+  return { json: response.data, human: `Related ${issue} to ${relatedIssue} as ${type}
+` };
+}
+async function relationUpdate(ctx, issue, idOrIssue, type) {
+  requireIdentifiers([issue]);
+  requireRelationType(type, RELATION_UPDATE_TYPES, "update");
+  const id = await resolveRelationId(ctx, issue, idOrIssue);
+  const response = await ctx.client.patch(`/api/v1/issues/${issue}/relations/${id}`, { type });
+  return { json: response.data, human: `Updated relation ${id} on ${issue} to ${type}
+` };
+}
+async function relationRm(ctx, issue, idOrIssue) {
+  requireIdentifiers([issue]);
+  const id = await resolveRelationId(ctx, issue, idOrIssue);
+  await ctx.client.delete(`/api/v1/issues/${issue}/relations/${id}`);
+  return { json: { deleted: id }, human: `Removed relation ${id} from ${issue}
+` };
+}
 async function comment(ctx, identifier, textWords, mentions) {
   requireIdentifiers([identifier]);
   if (textWords.length === 0) {
@@ -818,6 +901,40 @@ async function comment(ctx, identifier, textWords, mentions) {
   return { json: response.data, human: `Commented on ${identifier}
 ` };
 }
+async function editComment(ctx, identifier, commentId, textWords) {
+  requireIdentifiers([identifier]);
+  requireCommentId(commentId);
+  const body = textWords.join(" ");
+  if (body.trim() === "") {
+    throw new UsageError("the comment text is empty \u2014 nothing to edit");
+  }
+  const response = await ctx.client.patch(
+    `/api/v1/issues/${identifier}/comments/${commentId}`,
+    { body }
+  );
+  return {
+    json: response.data,
+    human: `Edited comment ${commentId} on ${identifier}
+`
+  };
+}
+async function deleteComment(ctx, identifier, commentId) {
+  requireIdentifiers([identifier]);
+  requireCommentId(commentId);
+  const response = await ctx.client.delete(
+    `/api/v1/issues/${identifier}/comments/${commentId}`
+  );
+  return {
+    json: response.data,
+    human: `Deleted comment ${commentId} from ${identifier}
+`
+  };
+}
+function requireCommentId(commentId) {
+  if (!UUID_FORMAT.test(commentId)) {
+    throw new UsageError(`not a comment id: ${commentId} (expected a UUID)`);
+  }
+}
 var MAX_ATTACHMENT_BYTES2 = 25e6;
 async function attachImage(ctx, path2) {
   attachableFile(path2);
@@ -902,27 +1019,136 @@ function validateType(type) {
     throw new UsageError(`not an issue type: ${type} (expected ${ISSUE_TYPES.join(", ")})`);
   }
 }
-async function applyLabels(ctx, issue, names) {
-  if (names.length === 0) return issue;
-  const labelsBody = await ctx.client.get("/api/v1/labels");
-  const byName = new Map(labelsBody.data.map((label) => [str2(label["name"]), label["id"]]));
+function requestedLabelNames(names) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const name of requestedLabelInputs(names)) {
+    const normalized = normalizeLabelName(name);
+    if (!unique.has(normalized)) unique.set(normalized, name);
+  }
+  return [...unique.values()];
+}
+function requestedLabelInputs(values) {
+  return values.map((value) => {
+    const trimmed = value.trim();
+    if (trimmed === "") throw new UsageError("label names and ids cannot be empty");
+    return trimmed;
+  });
+}
+function normalizeLabelName(value) {
+  return str2(value).trim().toLowerCase();
+}
+async function prepareCreateLabelIds(ctx, teamKey, names) {
+  if (names.length === 0) return [];
+  const teams = await ctx.client.get("/api/v1/teams");
+  const target = teams.data.find(
+    (team) => str2(team["key"]).toLowerCase() === teamKey.toLowerCase()
+  );
+  if (target === void 0) throw new CommandError(`No team matches key "${teamKey}".`);
+  const teamId = str2(target["id"]);
+  if (teamId === "") throw new CommandError(`team ${teamKey} carried no id`);
+  return prepareApplicableLabelIds(ctx, teamId, names);
+}
+async function prepareApplicableLabelIds(ctx, teamId, names) {
+  let labels = (await ctx.client.get("/api/v1/labels")).data;
   const ids = [];
   for (const name of names) {
-    const existing = byName.get(name);
-    if (existing !== void 0) {
-      ids.push(existing);
-    } else {
-      const created = await ctx.client.post("/api/v1/labels", {
-        name,
-        color: "gray"
-      });
-      ids.push(created.data["id"]);
+    const resolved = await resolveOrCreateApplicableLabel(ctx, labels, name, teamId);
+    labels = resolved.catalog;
+    ids.push(labelId(resolved.label));
+  }
+  return [...new Set(ids)];
+}
+function applicableLabel(labels, input, teamId) {
+  const normalized = normalizeLabelName(input);
+  const named = labels.filter((label) => normalizeLabelName(label["name"]) === normalized);
+  const teamMatches = named.filter((label) => label["team_id"] === teamId);
+  if (teamMatches.length > 1) {
+    throw new CommandError(`more than one team label matches "${input}"; use a label id`);
+  }
+  if (teamMatches.length === 1) return teamMatches[0];
+  const workspaceMatches = named.filter(
+    (label) => label["team_id"] === null || label["team_id"] === void 0
+  );
+  if (workspaceMatches.length > 1) {
+    throw new CommandError(`more than one workspace label matches "${input}"; use a label id`);
+  }
+  return workspaceMatches[0];
+}
+async function resolveOrCreateApplicableLabel(ctx, catalog, name, teamId) {
+  const existing = applicableLabel(catalog, name, teamId);
+  if (existing !== void 0) return { label: existing, catalog };
+  try {
+    const created = await ctx.client.post("/api/v1/labels", {
+      name,
+      color: "gray"
+    });
+    return { label: created.data, catalog: [...catalog, created.data] };
+  } catch (error) {
+    if (!(error instanceof HttpError) || error.status !== 422) throw error;
+    const refreshed = (await ctx.client.get("/api/v1/labels")).data;
+    const winner = applicableLabel(refreshed, name, teamId);
+    if (winner === void 0) throw error;
+    return { label: winner, catalog: refreshed };
+  }
+}
+function labelId(label) {
+  const id = str2(label["id"]);
+  if (id === "") throw new CommandError("the label response carried no id");
+  return id;
+}
+async function prepareLabelUpdate(ctx, identifier, addInputs, removeInputs) {
+  const issue = (await ctx.client.get(`/api/v1/issues/${identifier}`)).data;
+  const attached = Array.isArray(issue["labels"]) ? issue["labels"] : [];
+  const originalIds = attached.map(labelId);
+  const removed = /* @__PURE__ */ new Set();
+  for (const input of removeInputs) {
+    const idInput = UUID_FORMAT.test(input);
+    const exact = attached.find((label) => {
+      const id = labelId(label);
+      return idInput ? id.toLowerCase() === input.toLowerCase() : id === input;
+    });
+    if (exact !== void 0) {
+      removed.add(labelId(exact));
+      continue;
+    }
+    const normalized = normalizeLabelName(input);
+    const matches = attached.filter((label) => normalizeLabelName(label["name"]) === normalized);
+    if (matches.length > 1) {
+      throw new CommandError(`more than one attached label matches "${input}"; remove by label id`);
+    }
+    if (matches.length === 1) removed.add(labelId(matches[0]));
+  }
+  const ids = originalIds.filter((id) => !removed.has(id));
+  if (addInputs.length > 0) {
+    const team = issue["team"] ?? {};
+    const teamId = str2(team["id"]);
+    if (teamId === "") throw new CommandError(`issue ${identifier} carried no team id`);
+    let catalog = (await ctx.client.get("/api/v1/labels")).data;
+    for (const input of addInputs) {
+      const idInput = UUID_FORMAT.test(input);
+      let chosen = idInput ? catalog.find((label) => labelId(label).toLowerCase() === input.toLowerCase()) : void 0;
+      if (chosen !== void 0) {
+        const owner = chosen["team_id"];
+        if (owner !== null && owner !== void 0 && owner !== teamId) {
+          throw new CommandError(
+            `label ${input} belongs to another team and cannot be added to ${identifier}`
+          );
+        }
+      } else {
+        if (idInput) throw new CommandError(`No label matches id "${input}".`);
+        const resolved = await resolveOrCreateApplicableLabel(ctx, catalog, input, teamId);
+        chosen = resolved.label;
+        catalog = resolved.catalog;
+      }
+      const id = labelId(chosen);
+      if (!ids.includes(id)) ids.push(id);
     }
   }
-  const body = await ctx.client.put(`/api/v1/issues/${str2(issue["identifier"])}/labels`, {
-    label_ids: ids
-  });
-  return body.data;
+  return {
+    issue,
+    ids,
+    changed: ids.length !== originalIds.length || ids.some((id, index) => id !== originalIds[index])
+  };
 }
 async function fetchIssues(ctx, params, opts) {
   if (opts.all === true && opts.page !== void 0) {
@@ -1231,13 +1457,36 @@ async function linkAdd(ctx, issue, url, title) {
   return { json: response.data, human: `Linked ${clean(url)} to ${issue}
 ` };
 }
-async function linkRm(ctx, issue, idOrUrl) {
-  requireIdentifiers([issue]);
+async function findLink(ctx, issue, idOrUrl, allowDuplicateUrl = false) {
   const body = await ctx.client.get(`/api/v1/issues/${issue}/links`);
-  const link = body.data.find((candidate) => candidate["id"] === idOrUrl || candidate["url"] === idOrUrl);
-  if (link === void 0) {
+  const idMatch = body.data.find((candidate) => candidate["id"] === idOrUrl);
+  if (idMatch !== void 0) return idMatch;
+  const urlMatches = body.data.filter((candidate) => candidate["url"] === idOrUrl);
+  if (urlMatches.length > 1 && !allowDuplicateUrl) {
+    throw new CommandError(`multiple links on ${issue} match ${idOrUrl}; use a link id`);
+  }
+  if (urlMatches.length === 0) {
     throw new CommandError(`no link on ${issue} matches ${idOrUrl} (by id or exact URL)`);
   }
+  return urlMatches[0];
+}
+async function linkUpdate(ctx, issue, idOrUrl, opts) {
+  requireIdentifiers([issue]);
+  let patch = {};
+  patch = putOpt2(patch, "url", opts.url);
+  patch = putOpt2(patch, "title", opts.title);
+  if (Object.keys(patch).length === 0) {
+    throw new UsageError("usage: harness link update <issue> <link-id-or-url> --url <url> | --title <title>");
+  }
+  const id = isUuid(idOrUrl) ? idOrUrl.toLowerCase() : str3((await findLink(ctx, issue, idOrUrl))["id"]);
+  if (!isUuid(idOrUrl)) patch["expected_url"] = idOrUrl;
+  const response = await ctx.client.patch(`/api/v1/issues/${issue}/links/${id}`, patch);
+  return { json: response.data, human: `Updated link ${clean(response.data["url"])} on ${issue}
+` };
+}
+async function linkRm(ctx, issue, idOrUrl) {
+  requireIdentifiers([issue]);
+  const link = await findLink(ctx, issue, idOrUrl, true);
   await ctx.client.delete(`/api/v1/issues/${issue}/links/${str3(link["id"])}`);
   return { json: { deleted: link["id"] }, human: `Removed ${clean(link["url"])} from ${issue}
 ` };
@@ -1709,7 +1958,16 @@ export {
   archive,
   comments,
   dep,
+  RELATION_CREATE_TYPES,
+  RELATION_UPDATE_TYPES,
+  relationList,
+  relationAdd,
+  relationUpdate,
+  relationRm,
   comment,
+  editComment,
+  deleteComment,
+  requireCommentId,
   attachImage,
   projectList,
   projectShow,
@@ -1723,6 +1981,7 @@ export {
   docUpdate,
   linkList,
   linkAdd,
+  linkUpdate,
   linkRm,
   labelList,
   labelCreate,