teamwork-os 2.0.2

package/packages/gateway/dist/mcp/gateway-server.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+
+// packages/gateway/dist/mcp/gateway-server.js
+import { createInterface } from "node:readline";
+
+// packages/gateway/dist/mcp/tools.js
+var GATEWAY_TOOLS = [
+  {
+    name: "whoami",
+    description: "Report this session's own runtime identity from first-party gateway data: the Job that dispatched it, if any. sessionId is null for job runs and dry-runs (the spawn env carries no session id today). Use this to confirm where you are running before acting on that assumption.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "get_status",
+    description: "Gateway + scheduled-jobs summary: gateway version and uptime, the scheduler pause state, and per-job {id, name, schedule, enabled, lastStatus, lastRun, nextRun}.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    // Wire name kept from the legacy gateway even though CONTEXT.md bans
+    // 'cron' as a synonym for Job: `teamos migrate` imports legacy job
+    // prompts that call create_cron_job by name, and a rename would silently
+    // break every one of them. A documented compat exception, same as the legacy wire
+    // names in shared events.ts — every NEW surface says "Job".
+    name: "create_cron_job",
+    description: "Create a scheduled Job. Same validation path as POST /api/jobs: id (slug), schedule (5-field cron), and exactly one of prompt or command are required; optional name, description, timezone, timeoutSec, catchUp ('run-once' | 'skip'), retentionDays, enabled \u2014 plus the run-identity fields a Job carries itself: model, permissionMode, branch, useWorktree, persona, spendCapUsd.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Job id \u2014 letters, numbers, hyphens (also the JSON filename stem)" },
+        name: { type: "string", description: "Display name (defaults to the id)" },
+        description: { type: "string", description: "What the job does" },
+        schedule: { type: "string", description: '5-field cron expression, e.g. "0 9 * * 1-5"' },
+        timezone: { type: "string", description: "IANA timezone for the schedule (default: host timezone)" },
+        prompt: { type: "string", description: "Claude prompt \u2014 mutually exclusive with command" },
+        command: { type: "string", description: "Shell command \u2014 mutually exclusive with prompt" },
+        cwd: { type: "string", description: "Absolute working directory for the run" },
+        timeoutSec: { type: "number", description: "Wall-clock budget per run in seconds (default 900)" },
+        model: {
+          type: "string",
+          description: "Capability alias (low, medium, high, elite, legendary) or a concrete model id. Omit for the engine default."
+        },
+        permissionMode: {
+          type: "string",
+          description: "Permission posture of the spawned session: 'bypassPermissions' (default \u2014 what every job does today), 'acceptEdits', 'default', or 'plan'. Headless runs have nobody to prompt, so the non-bypass modes DENY un-permitted tool calls rather than asking."
+        },
+        branch: { type: "string", description: "Git ref the run works from (base for the worktree when useWorktree is set)" },
+        useWorktree: {
+          type: "boolean",
+          description: "Run in a throwaway git worktree cut from branch instead of directly in cwd (default false)"
+        },
+        persona: { type: "string", description: "Persona text appended to the system prompt on every turn" },
+        spendCapUsd: { type: "number", description: "Per-calendar-day spend cap in USD; reaching it skips this job's dispatch until the next day" },
+        catchUp: { type: "string", description: "Missed-run policy: 'run-once' (default) or 'skip'" },
+        retentionDays: { type: "number", description: "Per-job artifact retention override in days" },
+        enabled: { type: "boolean", description: "Whether the schedule fires (default true)" }
+      },
+      required: ["id", "schedule"]
+    }
+  },
+  {
+    name: "register_slack_root_post",
+    description: "Post a message to Slack as the gateway bot and register it as this run's ROOT post. Everything people reply in that thread accumulates into one session, spawned with CT_JOB_ID set to this jobId, and replies need no @-mention. Pass threadTs to add to an existing root instead of opening a new thread. The channel must be one the gateway is configured for (mapped in channels.directory, or one the connector has already dispatched a turn in).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: "Slack channel id, e.g. C0123456789" },
+        text: { type: "string", description: "Message body (Markdown is converted to Slack mrkdwn)" },
+        jobId: { type: "string", description: "Job this post belongs to" },
+        threadTs: {
+          type: "string",
+          description: "Existing root ts to post into. Omit to start a new thread."
+        }
+      },
+      required: ["channel", "text", "jobId"]
+    }
+  }
+];
+
+// packages/gateway/dist/mcp/api-client.js
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// packages/shared/dist/env-file.js
+var KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvFile(raw) {
+  const entries = [];
+  for (const rawLine of raw.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEY_RE.test(key))
+      continue;
+    entries.push({ key, value: stripQuotes(line.slice(eq + 1).trim()) });
+  }
+  return entries;
+}
+function stripQuotes(raw) {
+  if (raw.length >= 2) {
+    if (raw.startsWith("'") && raw.endsWith("'")) {
+      return raw.slice(1, -1).replace(/'\\''/g, "'");
+    }
+    if (raw.startsWith('"') && raw.endsWith('"')) {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw;
+}
+
+// packages/shared/dist/model-aliases.js
+var DEFAULT_MODEL_ALIASES = {
+  legendary: { model: "claude-fable-5", effortLevel: "xhigh" },
+  elite: { model: "claude-opus-5", effortLevel: "xhigh" },
+  high: { model: "claude-opus-5", effortLevel: "medium" },
+  medium: { model: "claude-sonnet-5", effortLevel: "medium" },
+  low: { model: "claude-haiku-4-5-20251001" }
+};
+var MODEL_ALIAS_LABELS = {
+  legendary: "Legendary",
+  elite: "Elite",
+  high: "High",
+  medium: "Medium",
+  low: "Low"
+};
+function formatModelAliasTarget(target) {
+  const model = target.model.replace(/^claude-/, "");
+  return target.effortLevel ? `${model} @ ${target.effortLevel}` : model;
+}
+var MODEL_ALIAS_OPTIONS = [
+  "legendary",
+  "elite",
+  "high",
+  "medium",
+  "low"
+].map((value) => {
+  const alias = value;
+  return {
+    value: alias,
+    label: `${MODEL_ALIAS_LABELS[alias]} \xB7 ${formatModelAliasTarget(DEFAULT_MODEL_ALIASES[alias])}`
+  };
+});
+
+// packages/shared/dist/claude-jsonl/normalize.js
+var MAX_TOOL_RESULT_BYTES = 64 * 1024;
+
+// packages/shared/dist/migrate/plan.js
+var TIMEOUT_SEC_MAX = 6 * 60 * 60;
+var PERSONA_MAX_LEN = 64 * 1024;
+
+// packages/gateway/dist/mcp/api-client.js
+var SESSION_COOKIE_NAME = "__Host-session";
+var GATEWAY_URL = process.env.CT_GATEWAY_URL || "http://127.0.0.1:7463";
+var cachedSessionCookie = null;
+function teamworkHome() {
+  return process.env.TEAMWORK_HOME ?? path.join(os.homedir(), ".teamwork");
+}
+function readAuthToken() {
+  const fromEnv = process.env.AUTH_TOKEN?.trim();
+  if (fromEnv)
+    return fromEnv;
+  try {
+    const envPath = path.join(teamworkHome(), ".env");
+    if (!fs.existsSync(envPath))
+      return null;
+    const entry = parseEnvFile(fs.readFileSync(envPath, "utf8")).find((e) => e.key === "AUTH_TOKEN");
+    const v = entry?.value.trim();
+    return v && v.length > 0 ? v : null;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.warn(`gateway-mcp: could not read AUTH_TOKEN from the teamwork env file (${code ?? "unknown"}): ${err.message}`);
+    }
+    return null;
+  }
+}
+async function loginForCookie(base, token) {
+  try {
+    const res = await fetch(`${base}/api/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token })
+    });
+    if (!res.ok) {
+      console.warn(`gateway-mcp: AUTH_TOKEN rejected by gateway login (HTTP ${res.status}); requests will fail`);
+      return null;
+    }
+    const setCookie = res.headers.get("set-cookie");
+    if (!setCookie) {
+      console.warn("gateway-mcp: gateway login returned 2xx but no Set-Cookie header; requests will fail");
+      return null;
+    }
+    const m = setCookie.match(new RegExp(`${SESSION_COOKIE_NAME}=([^;]+)`));
+    if (!m) {
+      console.warn(`gateway-mcp: gateway Set-Cookie did not contain ${SESSION_COOKIE_NAME}; requests will fail`);
+      return null;
+    }
+    return m[1];
+  } catch (err) {
+    console.warn(`gateway-mcp: gateway login request failed at ${base}/api/auth/login: ${err.message}`);
+    return null;
+  }
+}
+async function authenticatedFetch(url, init) {
+  const token = readAuthToken();
+  if (!token)
+    return fetch(url, init);
+  const base = new URL(url).origin;
+  if (!cachedSessionCookie) {
+    cachedSessionCookie = await loginForCookie(base, token);
+  }
+  const send = async (cookie) => {
+    const headers = new Headers(init?.headers);
+    if (cookie)
+      headers.set("Cookie", `${SESSION_COOKIE_NAME}=${cookie}`);
+    return fetch(url, { ...init, headers });
+  };
+  const first = await send(cachedSessionCookie);
+  if (first.status === 401 && cachedSessionCookie !== null) {
+    cachedSessionCookie = await loginForCookie(base, token);
+    return send(cachedSessionCookie);
+  }
+  return first;
+}
+async function apiGet(apiPath) {
+  const res = await authenticatedFetch(`${GATEWAY_URL}${apiPath}`);
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`API ${apiPath}: ${res.status} ${text || res.statusText}`);
+  }
+  return res.json();
+}
+async function apiPost(apiPath, body) {
+  const res = await authenticatedFetch(`${GATEWAY_URL}${apiPath}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`API ${apiPath}: ${res.status} ${text || res.statusText}`);
+  }
+  return res.json();
+}
+
+// packages/gateway/dist/mcp/gateway-server.js
+async function handleTool(name, args) {
+  switch (name) {
+    case "whoami": {
+      const sessionId = process.env.CT_SESSION_ID;
+      const jobId = process.env.CT_JOB_ID;
+      if (!sessionId && !jobId) {
+        return "Error: no session context available (CT_SESSION_ID / CT_JOB_ID are not set for this MCP server)";
+      }
+      const identity = {
+        sessionId: sessionId ?? null,
+        jobId: jobId ?? null
+      };
+      if (sessionId && /^[a-zA-Z0-9_-]{8,64}$/.test(sessionId)) {
+        try {
+          const session = await apiGet(`/api/sessions/${sessionId}`);
+          const s = session.session ?? session;
+          identity.status = s.status ?? null;
+          identity.cwd = s.cwd ?? null;
+          identity.title = s.title ?? null;
+        } catch (err) {
+          identity.sessionLookupError = err instanceof Error ? err.message : String(err);
+        }
+      }
+      return JSON.stringify(identity);
+    }
+    case "get_status": {
+      const status = await apiGet("/api/scheduler");
+      return JSON.stringify(status);
+    }
+    case "create_cron_job": {
+      const hasPrompt = typeof args.prompt === "string" && args.prompt.trim().length > 0;
+      const hasCommand = typeof args.command === "string" && args.command.trim().length > 0;
+      if (!hasPrompt && !hasCommand) {
+        return "Error: exactly one of prompt or command is required";
+      }
+      const result = await apiPost("/api/jobs", { enabled: true, ...args });
+      return JSON.stringify(result);
+    }
+    case "register_slack_root_post": {
+      const result = await apiPost("/api/slack/root-post", args);
+      return JSON.stringify(result);
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+function sendResponse(response) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}
+async function handleRequest(request) {
+  const { id, method, params } = request;
+  switch (method) {
+    case "initialize":
+      sendResponse({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: {
+            name: "teamwork-os-gateway",
+            version: "0.2.0"
+          }
+        }
+      });
+      break;
+    case "tools/list":
+      sendResponse({
+        jsonrpc: "2.0",
+        id,
+        result: { tools: GATEWAY_TOOLS }
+      });
+      break;
+    case "tools/call": {
+      const toolName = params?.name;
+      const toolArgs = params?.arguments || {};
+      try {
+        const result = await handleTool(toolName, toolArgs);
+        sendResponse({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: result }]
+          }
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        sendResponse({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true
+          }
+        });
+      }
+      break;
+    }
+    case "notifications/initialized":
+      break;
+    default:
+      sendResponse({
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32601, message: `Method not found: ${method}` }
+      });
+  }
+}
+if (process.env.TEAMOS_MCP_SERVER_NO_LISTEN !== "1") {
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      return;
+    }
+    handleRequest(request).catch((err) => {
+      sendResponse({
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      });
+    });
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+export {
+  handleTool
+};

package/packages/gateway/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@teamwork-os/gateway",
+  "version": "2.0.2",
+  "private": true,
+  "type": "module"
+}