@borgee/agents-host 0.2.2 → 0.2.28

package/skills/borgee-agent/borgee-agent.mjs

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+
+import { readFile } from 'node:fs/promises';
+
+const TASK_THREAD_COLLECTION_COMMAND_ERROR
+  = 'Task assignment threads only support --get-task and --update-task. Create/list tasks belong to the parent channel.';
+const TASK_THREAD_MISSING_TASK_ID_ERROR
+  = 'Task assignment thread could not resolve the current task from persisted context or local fallback. Pass --task-id explicitly.';
+
+function parseArgs(argv) {
+  let contextPath;
+  let authPath;
+  let turnExecutionId;
+  let action = 'print-bootstrap';
+  let limit;
+  let before;
+  let after;
+  let body;
+  let replyToId;
+  let mentionTargetId;
+  let title;
+  let description;
+  let assigneeId;
+  let taskId;
+  let status;
+  const mentions = [];
+
+  function setAction(nextAction) {
+    if (action !== 'print-bootstrap') {
+      throw new Error('Only one action flag may be used per invocation');
+    }
+    action = nextAction;
+  }
+
+  function parseIntegerOption(flag, value) {
+    if (value == null) {
+      throw new Error(`Missing value after ${flag}`);
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) {
+      throw new Error(`Invalid integer for ${flag}: ${value}`);
+    }
+    return parsed;
+  }
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--context') {
+      contextPath = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--auth-path') {
+      authPath = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--turn-execution-id') {
+      turnExecutionId = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--print-bootstrap') {
+      action = 'print-bootstrap';
+      continue;
+    }
+    if (arg === '--health') {
+      setAction('health');
+      continue;
+    }
+    if (arg === '--read-bootstrap') {
+      setAction('read-bootstrap');
+      continue;
+    }
+    if (arg === '--get-me') {
+      setAction('get-me');
+      continue;
+    }
+    if (arg === '--read-history') {
+      setAction('read-history');
+      continue;
+    }
+    if (arg === '--read-draft') {
+      setAction('read-draft');
+      continue;
+    }
+    if (arg === '--list-users') {
+      setAction('list-users');
+      continue;
+    }
+    if (arg === '--send-message') {
+      setAction('send-message');
+      continue;
+    }
+    if (arg === '--send-mention') {
+      setAction('send-mention');
+      mentionTargetId = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--create-task') {
+      setAction('create-task');
+      continue;
+    }
+    if (arg === '--list-tasks') {
+      setAction('list-tasks');
+      continue;
+    }
+    if (arg === '--get-task') {
+      setAction('get-task');
+      continue;
+    }
+    if (arg === '--update-task') {
+      setAction('update-task');
+      continue;
+    }
+    if (arg === '--limit') {
+      limit = parseIntegerOption(arg, argv[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === '--before') {
+      before = parseIntegerOption(arg, argv[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === '--after') {
+      after = parseIntegerOption(arg, argv[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === '--body') {
+      body = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--reply-to') {
+      replyToId = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--mention') {
+      const mention = argv[index + 1];
+      if (mention == null || mention.trim().length === 0) {
+        throw new Error('Missing value after --mention');
+      }
+      mentions.push(mention.trim());
+      index += 1;
+      continue;
+    }
+    if (arg === '--title') {
+      title = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--description') {
+      description = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--assignee-id') {
+      assigneeId = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--task-id') {
+      taskId = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--status') {
+      status = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!contextPath) {
+    throw new Error('Missing required --context <path> argument');
+  }
+
+  return {
+    contextPath,
+    authPath,
+    turnExecutionId: turnExecutionId?.trim(),
+    action,
+    limit,
+    before,
+    after,
+    body,
+    replyToId,
+    mentionTargetId: mentionTargetId?.trim(),
+    mentions,
+    title,
+    description,
+    assigneeId,
+    taskId,
+    status,
+  };
+}
+
+function ensureVisibleMention(body, participantId) {
+  if (body.includes(`<@${participantId}>`)) {
+    return body;
+  }
+  const separator = /\s$/u.test(body) ? '' : ' ';
+  return `${body}${separator}<@${participantId}>`;
+}
+
+function ensureVisibleMentions(body, participantIds) {
+  return participantIds.reduce(
+    (nextBody, participantId) => ensureVisibleMention(nextBody, participantId),
+    body,
+  );
+}
+
+function explicitTaskIdProvided(options) {
+  return typeof options.taskId === 'string' && options.taskId.trim().length > 0;
+}
+
+function resolveTaskId(payload, action, options) {
+  const explicitTaskId = typeof options.taskId === 'string'
+    ? options.taskId.trim()
+    : '';
+  if (explicitTaskId) {
+    return explicitTaskId;
+  }
+  if (payload.taskAssignmentContext?.active === true) {
+    const persistedTaskId = typeof payload.taskAssignmentContext.currentTaskId === 'string'
+      ? payload.taskAssignmentContext.currentTaskId.trim()
+      : '';
+    if (persistedTaskId) {
+      return persistedTaskId;
+    }
+    return null;
+  }
+  throw new Error(`Missing required --task-id <value> for --${action}`);
+}
+
+function resolveGatewayRequest(payload, action, options) {
+  const gateway = payload.localhostGateway;
+  if (!gateway?.baseUrl) {
+    throw new Error('Missing localhostGateway bootstrap metadata in the context payload');
+  }
+  if ((action === 'create-task' || action === 'list-tasks') && payload.taskAssignmentContext?.active === true) {
+    throw new Error(TASK_THREAD_COLLECTION_COMMAND_ERROR);
+  }
+  const encodedChannelId = encodeURIComponent(String(payload.channelId ?? ''));
+  switch (action) {
+    case 'health':
+      return { url: new URL('/health', gateway.baseUrl), method: 'GET' };
+    case 'read-bootstrap':
+      return { url: new URL(`/v1/channels/${encodedChannelId}/bootstrap`, gateway.baseUrl), method: 'GET' };
+    case 'get-me':
+      return { url: new URL(`/v1/channels/${encodedChannelId}/me`, gateway.baseUrl), method: 'GET' };
+    case 'read-history': {
+      const url = new URL(`/v1/channels/${encodedChannelId}/history`, gateway.baseUrl);
+      if (options.limit != null) {
+        url.searchParams.set('limit', String(options.limit));
+      }
+      if (options.before != null) {
+        url.searchParams.set('before', String(options.before));
+      }
+      if (options.after != null) {
+        url.searchParams.set('after', String(options.after));
+      }
+      return { url, method: 'GET' };
+    }
+    case 'read-draft': {
+      if (!options.turnExecutionId || options.turnExecutionId.trim().length === 0) {
+        throw new Error('Missing required --turn-execution-id value for --read-draft');
+      }
+      const url = new URL(`/v1/channels/${encodedChannelId}/draft`, gateway.baseUrl);
+      url.searchParams.set('turnExecutionId', options.turnExecutionId.trim());
+      return { url, method: 'GET' };
+    }
+    case 'list-users':
+      return { url: new URL(`/v1/channels/${encodedChannelId}/users`, gateway.baseUrl), method: 'GET' };
+    case 'send-message':
+    case 'send-mention':
+      return { url: new URL(`/v1/channels/${encodedChannelId}/messages`, gateway.baseUrl), method: 'POST' };
+    case 'create-task': {
+      if (!options.title) {
+        throw new Error('Missing required --title <value> for --create-task');
+      }
+      return {
+        url: new URL(`/v1/channels/${encodedChannelId}/tasks`, gateway.baseUrl),
+        method: 'POST',
+        body: {
+          title: options.title,
+          ...(options.description != null ? { description: options.description } : {}),
+          ...(options.assigneeId != null ? { assigneeId: options.assigneeId } : {}),
+        },
+      };
+    }
+    case 'list-tasks':
+      return { url: new URL(`/v1/channels/${encodedChannelId}/tasks`, gateway.baseUrl), method: 'GET' };
+    case 'get-task': {
+      const taskId = resolveTaskId(payload, action, options);
+      if (payload.taskAssignmentContext?.active === true && !explicitTaskIdProvided(options)) {
+        return {
+          url: new URL(`/v1/channels/${encodedChannelId}/current-task`, gateway.baseUrl),
+          method: 'GET',
+          usesCurrentThreadFallback: true,
+        };
+      }
+      return {
+        url: new URL(`/v1/tasks/${encodeURIComponent(taskId)}`, gateway.baseUrl),
+        method: 'GET',
+        usesCurrentThreadFallback: false,
+      };
+    }
+    case 'update-task': {
+      const taskId = resolveTaskId(payload, action, options);
+      const requestBody = {
+        ...(options.status != null ? { status: options.status } : {}),
+        ...(options.assigneeId != null ? { assigneeId: options.assigneeId } : {}),
+        ...(options.title != null ? { title: options.title } : {}),
+      };
+      if (Object.keys(requestBody).length === 0) {
+        throw new Error('At least one of --status, --assignee-id, or --title is required for --update-task');
+      }
+      if (payload.taskAssignmentContext?.active === true && !explicitTaskIdProvided(options)) {
+        return {
+          url: new URL(`/v1/channels/${encodedChannelId}/current-task`, gateway.baseUrl),
+          method: 'PATCH',
+          body: requestBody,
+          usesCurrentThreadFallback: true,
+        };
+      }
+      return {
+        url: new URL(`/v1/tasks/${encodeURIComponent(taskId)}`, gateway.baseUrl),
+        method: 'PATCH',
+        body: requestBody,
+        usesCurrentThreadFallback: false,
+      };
+    }
+    default:
+      throw new Error(`Unsupported gateway action: ${action}`);
+  }
+}
+
+async function readGatewayAuth(authPath, expectedChannelId) {
+  if (!authPath) {
+    throw new Error('Missing required --auth-path <path> argument for gateway access');
+  }
+  const authPayload = JSON.parse(await readFile(authPath, 'utf8'));
+  if (authPayload?.channelId !== expectedChannelId || !authPayload?.localhostGateway?.token) {
+    throw new Error('Missing localhost gateway auth payload for this channel');
+  }
+  return { token: authPayload.localhostGateway.token };
+}
+
+async function callGateway(payload, action, options) {
+  const request = resolveGatewayRequest(payload, action, options);
+  const auth = await readGatewayAuth(options.authPath, payload.channelId);
+  const httpRequest = {
+    method: request.method,
+    headers: auth.token
+      ? {
+          authorization: `Bearer ${auth.token}`,
+          ...(request.body || action === 'send-message' || action === 'send-mention'
+            ? { 'content-type': 'application/json; charset=utf-8' }
+            : {}),
+        }
+      : undefined,
+  };
+
+  if (action === 'send-message' || action === 'send-mention') {
+    if (!options.body || options.body.trim().length === 0) {
+      throw new Error(`Missing required --body value for --${action}`);
+    }
+    if (!options.turnExecutionId || options.turnExecutionId.trim().length === 0) {
+      throw new Error(`Missing required --turn-execution-id value for --${action}`);
+    }
+    const requestMentions =
+      action === 'send-mention'
+        ? [options.mentionTargetId?.trim()].filter(
+            (value) => typeof value === 'string' && value.length > 0,
+          )
+        : options.mentions;
+    if (action === 'send-mention' && requestMentions.length !== 1) {
+      throw new Error('Missing required target user id after --send-mention');
+    }
+    if (action === 'send-mention' && options.mentions.length > 0) {
+      throw new Error('Do not combine --send-mention with additional --mention flags');
+    }
+    const requestBody =
+      requestMentions.length > 0
+        ? ensureVisibleMentions(options.body, requestMentions)
+        : options.body;
+    httpRequest.body = JSON.stringify({
+      body: requestBody,
+      replyToId: options.replyToId,
+      turnExecutionId: options.turnExecutionId,
+    });
+  } else if (request.body) {
+    httpRequest.body = JSON.stringify(request.body);
+  }
+
+  const response = await fetch(request.url, httpRequest);
+  const bodyText = await response.text();
+  const responseBody = bodyText.length > 0 ? JSON.parse(bodyText) : null;
+  if (!response.ok) {
+    if (responseBody?.error === 'not_found' && request.usesCurrentThreadFallback === true) {
+      throw new Error(TASK_THREAD_MISSING_TASK_ID_ERROR);
+    }
+    throw new Error(`Gateway request failed with ${response.status}: ${JSON.stringify(responseBody)}`);
+  }
+  return responseBody;
+}
+
+function redactBootstrap(payload, contextPath) {
+  return {
+    kind: 'borgee-agent-skill-bootstrap',
+    contextPath,
+    channelId: payload.channelId,
+    skillRuntime: payload.skillRuntime ?? null,
+    taskAssignmentContext: payload.taskAssignmentContext ?? null,
+    localhostGateway: payload.localhostGateway?.baseUrl
+      ? {
+          baseUrl: payload.localhostGateway.baseUrl,
+          ...(payload.localhostGateway.collaboration
+            ? { collaboration: payload.localhostGateway.collaboration }
+            : {}),
+        }
+      : null,
+  };
+}
+
+const {
+  contextPath,
+  authPath,
+  turnExecutionId,
+  action,
+  limit,
+  before,
+  after,
+  body,
+  replyToId,
+  mentionTargetId,
+  mentions,
+  title,
+  description,
+  assigneeId,
+  taskId,
+  status,
+} = parseArgs(process.argv.slice(2));
+const payload = JSON.parse(await readFile(contextPath, 'utf8'));
+
+if (action === 'print-bootstrap') {
+  console.log(JSON.stringify(redactBootstrap(payload, contextPath), null, 2));
+} else {
+  const result = await callGateway(payload, action, {
+    contextPath,
+    authPath,
+    turnExecutionId,
+    limit,
+    before,
+    after,
+    body,
+    replyToId,
+    mentionTargetId,
+    mentions,
+    title,
+    description,
+    assigneeId,
+    taskId,
+    status,
+  });
+  console.log(JSON.stringify(result, null, 2));
+}