workq-mcp 0.1.0

package/README.md

@@ -0,0 +1,57 @@
+# workq-mcp
+
+Work Q MCP stdio bridge and local repository connection CLI.
+
+## Install
+
+```bash
+npm install -g workq-mcp
+```
+
+## Binaries
+
+- `workq-mcp`: stdio MCP bridge that forwards JSON-RPC to `https://work-q.nado.ai.kr/api/mcp`.
+- `workq`: helper CLI for one-time local repository connection.
+
+## Environment
+
+```bash
+WORKQ_MCP_URL=https://work-q.nado.ai.kr/api/mcp
+WORKQ_MCP_TOKEN_FILE=~/.workq/mcp-token
+# or
+WORKQ_MCP_TOKEN=<token>
+```
+
+## Connect A Local Repo
+
+Run this from the intended local git repository:
+
+```bash
+workq connect --project-key WORKQ
+```
+
+The CLI reads:
+
+```bash
+git rev-parse --show-toplevel
+git remote get-url origin
+git branch --show-current
+git rev-parse HEAD
+```
+
+Then it calls `workq_connect_local_project`.
+
+## Codex MCP Registration
+
+Example:
+
+```toml
+[mcp_servers.work_q]
+command = "/opt/homebrew/bin/workq-mcp"
+startup_timeout_sec = 30
+tool_timeout_sec = 300
+
+[mcp_servers.work_q.env]
+WORKQ_MCP_URL = "https://work-q.nado.ai.kr/api/mcp"
+WORKQ_MCP_TOKEN_FILE = "/Users/jin/.codex/workq-mcp-token"
+```

package/bin/workq-mcp.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+
+const endpoint = process.env.WORKQ_MCP_URL || "https://work-q.nado.ai.kr/api/mcp";
+const tokenFile =
+  process.env.WORKQ_MCP_TOKEN_FILE ||
+  `${os.homedir()}/.workq/mcp-token`;
+
+let buffer = Buffer.alloc(0);
+let outputMode = "line";
+let draining = Promise.resolve();
+let ended = false;
+
+function readToken() {
+  const directToken = process.env.WORKQ_MCP_TOKEN?.trim();
+  if (directToken) return directToken;
+  const token = fs.readFileSync(tokenFile, "utf8").trim();
+  if (!token) throw new Error(`Work Q MCP token file is empty: ${tokenFile}`);
+  return token;
+}
+
+function encodeMessage(message) {
+  const body = JSON.stringify(message);
+  if (outputMode === "headers") {
+    const length = Buffer.byteLength(body, "utf8");
+    return `Content-Length: ${length}\r\n\r\n${body}`;
+  }
+  return `${body}\n`;
+}
+
+function send(message) {
+  process.stdout.write(encodeMessage(message));
+}
+
+function sendError(id, code, message) {
+  send({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+}
+
+async function forward(message) {
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${readToken()}`,
+        "content-type": "application/json",
+        accept: "application/json"
+      },
+      body: JSON.stringify(message)
+    });
+
+    if (response.status === 204) return;
+
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        throw new Error(`Work Q MCP returned non-JSON response: ${text.slice(0, 300)}`);
+      }
+    }
+
+    if (!response.ok) {
+      const detail = payload?.error ?? response.statusText;
+      throw new Error(`Work Q MCP HTTP ${response.status}: ${detail}`);
+    }
+
+    if (payload) send(payload);
+  } catch (error) {
+    sendError(message?.id, -32000, error instanceof Error ? error.message : String(error));
+  }
+}
+
+function parseHeaderMessage() {
+  const headerEnd = buffer.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return null;
+
+  const header = buffer.subarray(0, headerEnd).toString("utf8");
+  const match = header.match(/content-length:\s*(\d+)/i);
+  if (!match) throw new Error("Missing Content-Length header");
+
+  const length = Number(match[1]);
+  const bodyStart = headerEnd + 4;
+  const bodyEnd = bodyStart + length;
+  if (buffer.length < bodyEnd) return null;
+
+  const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+  buffer = buffer.subarray(bodyEnd);
+  outputMode = "headers";
+  return JSON.parse(body);
+}
+
+function parseLineMessage() {
+  const newline = buffer.indexOf("\n");
+  if (newline === -1) return null;
+
+  const line = buffer.subarray(0, newline).toString("utf8").trim();
+  buffer = buffer.subarray(newline + 1);
+  outputMode = "line";
+  return line ? JSON.parse(line) : null;
+}
+
+async function drain() {
+  while (buffer.length) {
+    let message = null;
+    try {
+      const prefix = buffer.toString("utf8", 0, Math.min(buffer.length, 32)).toLowerCase();
+      message = prefix.startsWith("content-length:") ? parseHeaderMessage() : parseLineMessage();
+    } catch (error) {
+      sendError(null, -32700, error instanceof Error ? error.message : String(error));
+      buffer = Buffer.alloc(0);
+      return;
+    }
+
+    if (!message) return;
+    await forward(message);
+  }
+}
+
+function scheduleDrain() {
+  draining = draining
+    .then(() => drain())
+    .catch((error) => {
+      sendError(null, -32000, error instanceof Error ? error.message : String(error));
+    })
+    .then(() => {
+      if (ended && buffer.length === 0) process.exit(0);
+    });
+}
+
+process.stdin.on("data", (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  scheduleDrain();
+});
+
+process.stdin.on("end", () => {
+  ended = true;
+  scheduleDrain();
+});

package/bin/workq.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+
+const DEFAULT_ENDPOINT = "https://work-q.nado.ai.kr/api/mcp";
+
+function usage() {
+  process.stdout.write(`Work Q CLI
+
+Usage:
+  workq connect --project-key <KEY> [--device-label <LABEL>]
+  workq mcp
+
+Environment:
+  WORKQ_MCP_URL         Defaults to ${DEFAULT_ENDPOINT}
+  WORKQ_MCP_TOKEN      Direct MCP bearer token
+  WORKQ_MCP_TOKEN_FILE Token file path, defaults to ~/.workq/mcp-token
+
+Examples:
+  workq connect --project-key WORKQ
+  WORKQ_MCP_TOKEN_FILE=~/.codex/workq-mcp-token workq connect --project-key WORKQ
+`);
+}
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (!item.startsWith("--")) {
+      args._.push(item);
+      continue;
+    }
+    const key = item.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function required(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${name} is required`);
+  }
+  return value.trim();
+}
+
+function tokenFile() {
+  return process.env.WORKQ_MCP_TOKEN_FILE || `${os.homedir()}/.workq/mcp-token`;
+}
+
+function readToken() {
+  const directToken = process.env.WORKQ_MCP_TOKEN?.trim();
+  if (directToken) return directToken;
+  const file = tokenFile();
+  const token = fs.readFileSync(file, "utf8").trim();
+  if (!token) throw new Error(`Work Q MCP token file is empty: ${file}`);
+  return token;
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function parseRemote(remote) {
+  const ssh = remote.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i);
+  if (ssh) return { owner: ssh[1], repo: ssh[2].replace(/\.git$/i, "") };
+  const url = new URL(remote);
+  if (url.hostname.toLowerCase() !== "github.com") throw new Error(`Only github.com remotes are supported: ${remote}`);
+  const [owner, repo] = url.pathname.replace(/^\/+/, "").split("/");
+  if (!owner || !repo) throw new Error(`Could not parse GitHub remote: ${remote}`);
+  return { owner, repo: repo.replace(/\.git$/i, "") };
+}
+
+async function callMcp(name, argumentsPayload) {
+  const endpoint = process.env.WORKQ_MCP_URL || DEFAULT_ENDPOINT;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${readToken()}`,
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: `${name}-${Date.now()}`,
+      method: "tools/call",
+      params: {
+        name,
+        arguments: argumentsPayload
+      }
+    })
+  });
+
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : null;
+  if (!response.ok || payload?.error) {
+    throw new Error(payload?.error?.message || payload?.error || response.statusText);
+  }
+  return payload.result.structuredContent;
+}
+
+async function connect(args) {
+  const projectKey = required(args["project-key"] || args.project_key, "--project-key");
+  const localPath = git(["rev-parse", "--show-toplevel"]);
+  const gitRemoteUrl = git(["remote", "get-url", "origin"]);
+  const gitBranch = git(["branch", "--show-current"]);
+  const commitSha = git(["rev-parse", "HEAD"]);
+  const remote = parseRemote(gitRemoteUrl);
+  const deviceLabel = typeof args["device-label"] === "string" ? args["device-label"].trim() : `${os.hostname()} local`;
+
+  const result = await callMcp("workq_connect_local_project", {
+    project_key: projectKey,
+    device_label: deviceLabel,
+    local_path: localPath,
+    git_remote_url: gitRemoteUrl,
+    repository_owner: remote.owner,
+    repository_repo: remote.repo,
+    git_branch: gitBranch,
+    commit_sha: commitSha
+  });
+
+  process.stdout.write(`Connected Work Q local repository binding.
+project_key: ${result.service.project_key}
+binding_id: ${result.binding.id}
+status: ${result.binding.status}
+repo: ${result.binding.repository_full_name}
+local_path: ${result.binding.local_path}
+branch: ${result.binding.git_branch ?? ""}
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const command = args._[0];
+  if (!command || args.help || args.h) {
+    usage();
+    return;
+  }
+  if (command === "connect") {
+    await connect(args);
+    return;
+  }
+  if (command === "mcp") {
+    await import("./workq-mcp.mjs");
+    return;
+  }
+  throw new Error(`Unknown command: ${command}`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "workq-mcp",
+  "version": "0.1.0",
+  "description": "Work Q MCP stdio bridge and local repository connection CLI.",
+  "type": "module",
+  "bin": {
+    "workq-mcp": "bin/workq-mcp.mjs",
+    "workq": "bin/workq.mjs"
+  },
+  "files": [
+    "bin/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}