@h-rig/rig-extension 0.0.6-alpha.100

package/dist/src/workflow/identity.js

@@ -0,0 +1,429 @@
+// @bun
+// packages/rig-extension/src/workflow/projections.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+var EMPTY_PROJECTION = {
+  started: null,
+  target: null,
+  task: null,
+  status: null,
+  notes: [],
+  inbox: [],
+  resolvedInbox: [],
+  updatedAt: null
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function requiredString(value) {
+  const text = optionalString(value);
+  return text ?? null;
+}
+function timestamp(value) {
+  const text = requiredString(value);
+  if (!text)
+    return null;
+  const millis = Date.parse(text);
+  return Number.isFinite(millis) ? text : null;
+}
+function newer(left, right) {
+  if (!right)
+    return false;
+  if (!left)
+    return true;
+  return Date.parse(right) >= Date.parse(left);
+}
+function isWorkflowTarget(value) {
+  return value === "local" || value === "remote";
+}
+function isWorkflowStatus(value) {
+  return value === "starting" || value === "running" || value === "waiting-approval" || value === "waiting-input" || value === "completed" || value === "failed" || value === "stopped";
+}
+function isInboxKind(value) {
+  return value === "approval" || value === "input";
+}
+function isInboxDecision(value) {
+  return value === "approved" || value === "rejected" || value === "answered";
+}
+function parseOwner(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const githubUserId = requiredString(record.githubUserId);
+  const login = requiredString(record.login);
+  const namespaceKey = requiredString(record.namespaceKey);
+  return githubUserId && login && namespaceKey ? { githubUserId, login, namespaceKey } : null;
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const options = value.map(optionalString).filter((option) => option !== undefined);
+  return options.length > 0 ? options : undefined;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function entryUpdatedAt(entry) {
+  if ("createdAt" in entry)
+    return entry.createdAt;
+  if ("selectedAt" in entry)
+    return entry.selectedAt;
+  if ("changedAt" in entry)
+    return entry.changedAt;
+  if ("notedAt" in entry)
+    return entry.notedAt;
+  if ("requestedAt" in entry)
+    return entry.requestedAt;
+  return entry.resolvedAt;
+}
+function parseWorkflowStarted(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const workflowId = requiredString(record.workflowId);
+  const target = optionalString(record.target);
+  const selectedRepo = requiredString(record.selectedRepo);
+  const owner = parseOwner(record.owner);
+  const createdAt = timestamp(record.createdAt);
+  if (!workflowId || !isWorkflowTarget(target) || !selectedRepo || !owner || !createdAt)
+    return null;
+  return {
+    schemaVersion: 1,
+    workflowId,
+    target,
+    selectedRepo,
+    owner,
+    createdAt
+  };
+}
+function parseWorkflowTargetSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const target = optionalString(record.target);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!isWorkflowTarget(target) || !selectedAt)
+    return null;
+  const reason = optionalString(record.reason);
+  return {
+    schemaVersion: 1,
+    target,
+    ...reason ? { reason } : {},
+    selectedAt
+  };
+}
+function parseWorkflowTaskSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const taskId = requiredString(record.taskId);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!taskId || !selectedAt)
+    return null;
+  const title = optionalString(record.title);
+  return { schemaVersion: 1, taskId, ...title ? { title } : {}, selectedAt };
+}
+function parseWorkflowStatusChanged(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const status = optionalString(record.status);
+  const changedAt = timestamp(record.changedAt);
+  if (!changedAt || !isWorkflowStatus(status))
+    return null;
+  const detail = optionalString(record.detail);
+  return { schemaVersion: 1, status, ...detail ? { detail } : {}, changedAt };
+}
+function parseWorkflowOperatorNote(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const note = requiredString(record.note);
+  const notedAt = timestamp(record.notedAt);
+  if (!note || !notedAt)
+    return null;
+  const noteId = optionalString(record.noteId);
+  return { schemaVersion: 1, ...noteId ? { noteId } : {}, note, notedAt };
+}
+function parseWorkflowInboxRequested(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const kind = optionalString(record.kind);
+  const title = requiredString(record.title);
+  const requestedAt = timestamp(record.requestedAt);
+  if (!requestId || !isInboxKind(kind) || !title || !requestedAt)
+    return null;
+  const body = optionalString(record.body);
+  const options = parseStringArray(record.options);
+  return {
+    schemaVersion: 1,
+    requestId,
+    kind,
+    title,
+    ...body ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt
+  };
+}
+function parseWorkflowInboxResolved(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const decision = optionalString(record.decision);
+  const resolvedAt = timestamp(record.resolvedAt);
+  if (!requestId || !isInboxDecision(decision) || !resolvedAt)
+    return null;
+  const base = { schemaVersion: 1, requestId, decision, resolvedAt };
+  return hasOwn(record, "answer") ? { ...base, answer: record.answer } : base;
+}
+function collectPendingInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId)?.requestedAt, request.requestedAt))
+        requested.set(request.requestId, request);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId), resolution.resolvedAt))
+        resolved.set(resolution.requestId, resolution.resolvedAt);
+    }
+  }
+  for (const [requestId, request] of requested) {
+    const resolvedAt = resolved.get(requestId);
+    if (resolvedAt && Date.parse(resolvedAt) >= Date.parse(request.requestedAt))
+      requested.delete(requestId);
+  }
+  return Array.from(requested.values()).sort((a, b) => Date.parse(b.requestedAt) - Date.parse(a.requestedAt));
+}
+function collectResolvedInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId), request.requestedAt))
+        requested.set(request.requestId, request.requestedAt);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId)?.resolvedAt, resolution.resolvedAt)) {
+        resolved.set(resolution.requestId, resolution);
+      }
+    }
+  }
+  for (const [requestId, resolution] of resolved) {
+    const requestedAt = requested.get(requestId);
+    if (requestedAt && Date.parse(requestedAt) > Date.parse(resolution.resolvedAt))
+      resolved.delete(requestId);
+  }
+  return Array.from(resolved.values()).sort((a, b) => Date.parse(b.resolvedAt) - Date.parse(a.resolvedAt));
+}
+function projectWorkflowEntries(entries) {
+  let started = null;
+  let target = null;
+  let task = null;
+  let status = null;
+  const notes = [];
+  let updatedAt = null;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_STARTED) {
+      const parsed = parseWorkflowStarted(entry.data);
+      if (parsed && newer(started?.createdAt, parsed.createdAt))
+        started = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TARGET_SELECTED) {
+      const parsed = parseWorkflowTargetSelected(entry.data);
+      if (parsed && newer(target?.selectedAt, parsed.selectedAt))
+        target = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TASK_SELECTED) {
+      const parsed = parseWorkflowTaskSelected(entry.data);
+      if (parsed && newer(task?.selectedAt, parsed.selectedAt))
+        task = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_STATUS_CHANGED) {
+      const parsed = parseWorkflowStatusChanged(entry.data);
+      if (parsed && newer(status?.changedAt, parsed.changedAt))
+        status = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_OPERATOR_NOTE) {
+      const parsed = parseWorkflowOperatorNote(entry.data);
+      if (parsed)
+        notes.push(parsed);
+    }
+  }
+  notes.sort((a, b) => Date.parse(b.notedAt) - Date.parse(a.notedAt));
+  for (const value of [started, target, task, status, ...notes].map((entry) => entry ? entryUpdatedAt(entry) : null)) {
+    if (newer(updatedAt, value))
+      updatedAt = value;
+  }
+  const inbox = collectPendingInboxRequests(entries);
+  const resolvedInbox = collectResolvedInboxRequests(entries);
+  for (const entry of [...inbox, ...resolvedInbox]) {
+    if (newer(updatedAt, entryUpdatedAt(entry)))
+      updatedAt = entryUpdatedAt(entry);
+  }
+  if (!started && !target && !task && !status && notes.length === 0 && inbox.length === 0 && resolvedInbox.length === 0 && !updatedAt)
+    return EMPTY_PROJECTION;
+  return { started, target, task, status, notes, inbox, resolvedInbox, updatedAt };
+}
+
+// packages/rig-extension/src/workflow/identity.ts
+function stringField(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function numericStringField(value) {
+  return typeof value === "number" && Number.isInteger(value) ? String(value) : stringField(value);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function customEntries(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+function candidateFromStartedProjection(workflow) {
+  const started = workflow.started;
+  if (!started)
+    return null;
+  return {
+    selectedRepo: started.selectedRepo,
+    githubUserId: started.owner.githubUserId,
+    login: started.owner.login,
+    namespaceKey: started.owner.namespaceKey,
+    source: "workflow-metadata"
+  };
+}
+function candidateFromStartedData(data) {
+  const record = asRecord2(data);
+  if (!record)
+    return null;
+  const owner = asRecord2(record.owner);
+  const selectedRepo = stringField(record.selectedRepo);
+  const githubUserId = stringField(owner?.githubUserId) ?? numericStringField(record.githubUserId) ?? numericStringField(record.userId);
+  const login = stringField(owner?.login) ?? stringField(record.login);
+  const namespaceKey = stringField(owner?.namespaceKey) ?? stringField(record.namespaceKey) ?? stringField(record.userNamespaceKey);
+  if (!selectedRepo && !githubUserId && !login && !namespaceKey)
+    return null;
+  return { selectedRepo, githubUserId, login, namespaceKey, source: "workflow-metadata" };
+}
+function workflowIdentityCandidate(entries) {
+  const customs = customEntries(entries);
+  const projected = candidateFromStartedProjection(projectWorkflowEntries(customs));
+  if (projected)
+    return projected;
+  for (let index = customs.length - 1;index >= 0; index -= 1) {
+    const entry = customs[index];
+    if (entry?.customType !== RIG_WORKFLOW_STARTED)
+      continue;
+    const candidate = candidateFromStartedData(entry.data);
+    if (candidate)
+      return candidate;
+  }
+  return null;
+}
+function ompGitHubIdentityCandidate(ctx) {
+  const account = asRecord2(ctx.modelRegistry?.authStorage?.getOAuthAccountIdentity?.("github-copilot", ctx.sessionManager.getSessionId()));
+  if (!account)
+    return null;
+  const githubUserId = stringField(account.accountId);
+  const login = stringField(account.login) ?? stringField(account.email);
+  if (!githubUserId && !login)
+    return null;
+  return {
+    githubUserId,
+    login,
+    namespaceKey: githubUserId ? `gh:${githubUserId}` : undefined,
+    source: "omp-github-copilot-auth"
+  };
+}
+function envField(name) {
+  return stringField(process.env[name]);
+}
+function envIdentityCandidate() {
+  const selectedRepo = envField("RIG_SELECTED_REPO");
+  const githubUserId = envField("RIG_GITHUB_USER_ID");
+  const login = envField("RIG_GITHUB_LOGIN");
+  const namespaceKey = envField("RIG_GITHUB_NAMESPACE_KEY") ?? (githubUserId ? `gh:${githubUserId}` : undefined);
+  if (!selectedRepo && !githubUserId && !login && !namespaceKey)
+    return null;
+  return {
+    selectedRepo,
+    githubUserId,
+    login,
+    namespaceKey,
+    source: "rig-public-identity-env"
+  };
+}
+function mergeSource(sources, source) {
+  if (source && !sources.includes(source))
+    sources.push(source);
+}
+function completeIdentity(candidate, sources) {
+  const selectedRepo = stringField(candidate.selectedRepo);
+  const githubUserId = stringField(candidate.githubUserId);
+  const login = stringField(candidate.login);
+  const namespaceKey = stringField(candidate.namespaceKey);
+  if (!selectedRepo || !githubUserId || !login || !namespaceKey)
+    return null;
+  const uniqueSources = [];
+  for (const value of sources) {
+    if (!uniqueSources.includes(value))
+      uniqueSources.push(value);
+  }
+  return {
+    selectedRepo,
+    owner: { githubUserId, login, namespaceKey },
+    source: uniqueSources.join("+")
+  };
+}
+function resolveRigIdentity(ctx) {
+  const workflow = workflowIdentityCandidate(ctx.sessionManager.getBranch());
+  const omp = ompGitHubIdentityCandidate(ctx);
+  const env = envIdentityCandidate();
+  const sources = [];
+  const selectedRepo = workflow?.selectedRepo ?? env?.selectedRepo;
+  const githubUserId = workflow?.githubUserId ?? omp?.githubUserId ?? env?.githubUserId;
+  const login = workflow?.login ?? omp?.login ?? env?.login;
+  const namespaceKey = workflow?.namespaceKey ?? omp?.namespaceKey ?? env?.namespaceKey;
+  if (workflow && (workflow.selectedRepo || workflow.githubUserId || workflow.login || workflow.namespaceKey))
+    mergeSource(sources, workflow.source);
+  if (omp && (!workflow?.githubUserId || !workflow?.login || !workflow?.namespaceKey))
+    mergeSource(sources, omp.source);
+  if (env && (!workflow?.selectedRepo && env.selectedRepo || !workflow?.githubUserId && !omp?.githubUserId && env.githubUserId || !workflow?.login && !omp?.login && env.login || !workflow?.namespaceKey && !omp?.namespaceKey && env.namespaceKey))
+    mergeSource(sources, env.source);
+  return completeIdentity({ selectedRepo, githubUserId, login, namespaceKey, source: sources.join("+") }, sources);
+}
+function resolveRigIdentityFilter(ctx) {
+  const identity = resolveRigIdentity(ctx);
+  if (!identity)
+    return null;
+  return {
+    cwd: ctx.sessionManager.getCwd(),
+    selectedRepo: identity.selectedRepo,
+    githubUserId: identity.owner.githubUserId,
+    namespaceKey: identity.owner.namespaceKey
+  };
+}
+export {
+  resolveRigIdentityFilter,
+  resolveRigIdentity
+};