@schoolai/shipyard-mcp 0.1.0

package/apps/server/.env.example

@@ -0,0 +1,20 @@
+# Server Environment Variables
+# Copy this file to .env and adjust values for local development
+
+# Server configuration
+NODE_ENV=development
+LOG_LEVEL=info
+
+# Registry configuration
+REGISTRY_PORT=32191
+SHIPYARD_STATE_DIR=~/.shipyard
+
+# Web UI URL (for links generated by server)
+SHIPYARD_WEB_URL=http://localhost:5173
+
+# GitHub integration (optional - falls back to gh CLI)
+GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# GitHub artifacts feature (optional - defaults to enabled)
+# Set to 'disabled', 'false', or '0' to disable
+SHIPYARD_ARTIFACTS=true

package/apps/server/dist/chunk-7GPZDCWI.js

@@ -0,0 +1,158 @@
+import {
+  loadEnv,
+  logger
+} from "./chunk-GSGLHRWX.js";
+
+// src/server-identity.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/config/env/github.ts
+import { execSync } from "child_process";
+import { z } from "zod";
+function getTokenFromGhCli() {
+  try {
+    const token = execSync("gh auth token", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+      // Suppress stderr
+    }).trim();
+    if (token) {
+      return token;
+    }
+  } catch {
+  }
+  return null;
+}
+var schema = z.object({
+  GITHUB_USERNAME: z.string().optional(),
+  GITHUB_TOKEN: z.string().optional().transform((val) => val || getTokenFromGhCli() || null),
+  SHIPYARD_ARTIFACTS: z.string().optional().transform((val) => {
+    if (!val) return true;
+    const setting = val.toLowerCase();
+    return setting !== "disabled" && setting !== "false" && setting !== "0";
+  })
+});
+var githubConfig = loadEnv(schema);
+
+// src/server-identity.ts
+var cachedUsername = null;
+var usernameResolved = false;
+var cachedRepoName = null;
+function getRepositoryFullName() {
+  if (cachedRepoName !== null) {
+    return cachedRepoName || null;
+  }
+  try {
+    const repoName = execSync2("gh repo view --json nameWithOwner --jq .nameWithOwner", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!repoName) {
+      cachedRepoName = "";
+      return null;
+    }
+    cachedRepoName = repoName;
+    return cachedRepoName;
+  } catch {
+    cachedRepoName = "";
+    return null;
+  }
+}
+async function getGitHubUsername() {
+  if (usernameResolved && cachedUsername) {
+    return cachedUsername;
+  }
+  if (githubConfig.GITHUB_USERNAME) {
+    cachedUsername = githubConfig.GITHUB_USERNAME;
+    usernameResolved = true;
+    logger.info({ username: cachedUsername }, "Using GITHUB_USERNAME from env");
+    return cachedUsername;
+  }
+  if (githubConfig.GITHUB_TOKEN) {
+    const username = await getUsernameFromToken(githubConfig.GITHUB_TOKEN);
+    if (username) {
+      cachedUsername = username;
+      usernameResolved = true;
+      logger.info({ username }, "Resolved username from GITHUB_TOKEN via API");
+      return cachedUsername;
+    }
+  }
+  const cliUsername = getUsernameFromCLI();
+  if (cliUsername) {
+    cachedUsername = cliUsername;
+    usernameResolved = true;
+    logger.info({ username: cliUsername }, "Resolved username from gh CLI");
+    return cachedUsername;
+  }
+  const gitUsername = getUsernameFromGitConfig();
+  if (gitUsername) {
+    cachedUsername = gitUsername;
+    usernameResolved = true;
+    logger.warn({ username: gitUsername }, "Using git config user.name (UNVERIFIED)");
+    return cachedUsername;
+  }
+  const osUsername = process.env.USER || process.env.USERNAME;
+  if (osUsername) {
+    cachedUsername = osUsername.replace(/[^a-zA-Z0-9_-]/g, "_");
+    usernameResolved = true;
+    logger.warn(
+      { username: cachedUsername, original: osUsername },
+      "Using sanitized OS username (UNVERIFIED)"
+    );
+    return cachedUsername;
+  }
+  usernameResolved = true;
+  throw new Error(
+    'GitHub username required but could not be determined.\n\nConfigure ONE of:\n1. GITHUB_USERNAME=your-username (explicit)\n2. GITHUB_TOKEN=ghp_xxx (will fetch from API)\n3. gh auth login (uses CLI)\n4. git config --global user.name "your-username"\n5. Set USER or USERNAME environment variable\n\nFor remote agents: Use option 1 or 2'
+  );
+}
+async function getUsernameFromToken(token) {
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "shipyard-mcp-server"
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return null;
+    const user = await response.json();
+    return user.login || null;
+  } catch (error) {
+    logger.debug({ error }, "GitHub API failed");
+    return null;
+  }
+}
+function getUsernameFromCLI() {
+  try {
+    const username = execSync2("gh api user --jq .login", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return username || null;
+  } catch {
+    return null;
+  }
+}
+function getUsernameFromGitConfig() {
+  try {
+    const username = execSync2("git config user.name", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return username || null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  githubConfig,
+  getRepositoryFullName,
+  getGitHubUsername
+};

package/apps/server/dist/chunk-EBNL5ZX7.js

@@ -0,0 +1,120 @@
+import {
+  logger
+} from "./chunk-GSGLHRWX.js";
+
+// src/session-registry.ts
+function isSessionStateCreated(state) {
+  return state.lifecycle === "created";
+}
+function isSessionStateSynced(state) {
+  return state.lifecycle === "synced";
+}
+function isSessionStateApprovedAwaitingToken(state) {
+  return state.lifecycle === "approved_awaiting_token";
+}
+function isSessionStateApproved(state) {
+  return state.lifecycle === "approved";
+}
+function isSessionStateReviewed(state) {
+  return state.lifecycle === "reviewed";
+}
+function assertNever(value) {
+  throw new Error(`Unhandled discriminated union member: ${JSON.stringify(value)}`);
+}
+var sessions = /* @__PURE__ */ new Map();
+var planToSession = /* @__PURE__ */ new Map();
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function getSessionState(sessionId) {
+  return sessions.get(sessionId) ?? null;
+}
+function touchSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.lastSyncedAt = Date.now();
+  }
+}
+function setSessionState(sessionId, state) {
+  const updatedState = {
+    ...state,
+    lastSyncedAt: Date.now()
+  };
+  sessions.set(sessionId, updatedState);
+  planToSession.set(updatedState.planId, sessionId);
+}
+function deleteSessionState(sessionId) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    planToSession.delete(session.planId);
+  }
+  sessions.delete(sessionId);
+}
+function getSessionStateByPlanId(planId) {
+  const sessionId = planToSession.get(planId);
+  if (!sessionId) return null;
+  return getSessionState(sessionId);
+}
+function getSessionIdByPlanId(planId) {
+  return planToSession.get(planId) || null;
+}
+function cleanStaleSessions(ttlMs = DEFAULT_TTL_MS) {
+  const now = Date.now();
+  let cleaned = 0;
+  for (const [sessionId, session] of sessions.entries()) {
+    if (now - session.lastSyncedAt > ttlMs) {
+      const currentSessionId = planToSession.get(session.planId);
+      if (currentSessionId === sessionId) {
+        planToSession.delete(session.planId);
+      }
+      sessions.delete(sessionId);
+      cleaned++;
+    }
+  }
+  if (cleaned > 0) {
+    logger.info({ cleaned, ttlMs }, "Cleaned stale sessions from registry");
+  }
+  return cleaned;
+}
+function getActiveSessions() {
+  return Array.from(sessions.keys());
+}
+function getSessionCount() {
+  return sessions.size;
+}
+var cleanupInterval = null;
+function startPeriodicCleanup(intervalMs = 15 * 60 * 1e3) {
+  if (cleanupInterval) {
+    logger.warn("Periodic cleanup already started");
+    return;
+  }
+  cleanupInterval = setInterval(() => {
+    cleanStaleSessions();
+  }, intervalMs);
+  logger.info({ intervalMs }, "Started periodic session cleanup");
+}
+function stopPeriodicCleanup() {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+    logger.info("Stopped periodic session cleanup");
+  }
+}
+
+export {
+  isSessionStateCreated,
+  isSessionStateSynced,
+  isSessionStateApprovedAwaitingToken,
+  isSessionStateApproved,
+  isSessionStateReviewed,
+  assertNever,
+  getSessionState,
+  touchSession,
+  setSessionState,
+  deleteSessionState,
+  getSessionStateByPlanId,
+  getSessionIdByPlanId,
+  cleanStaleSessions,
+  getActiveSessions,
+  getSessionCount,
+  startPeriodicCleanup,
+  stopPeriodicCleanup
+};

package/apps/server/dist/chunk-GSGLHRWX.js

@@ -0,0 +1,62 @@
+// src/logger.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import pino from "pino";
+
+// src/config/env/server.ts
+import { z as z2 } from "zod";
+
+// src/config/config.ts
+import { z } from "zod";
+function loadEnv(schema2) {
+  try {
+    return schema2.parse(process.env);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const testResult = schema2.safeParse(void 0);
+      if (testResult.success) {
+        return testResult.data;
+      }
+      if (!error.issues || !Array.isArray(error.issues)) {
+        throw new Error("Environment variable validation failed (no error details available)");
+      }
+      const errorMessages = error.issues.map((err) => ` - ${err.path.join(".")}: ${err.message}`).join("\n");
+      throw new Error(`Environment variable validation failed: 
+${errorMessages}`);
+    }
+    throw error;
+  }
+}
+
+// src/config/env/server.ts
+var schema = z2.object({
+  NODE_ENV: z2.enum(["development", "test", "production"]).default("development"),
+  LOG_LEVEL: z2.enum(["debug", "info", "warn", "error"]).default("info")
+});
+var serverConfig = loadEnv(schema);
+
+// src/logger.ts
+var LOG_FILE = join(homedir(), ".shipyard", "server-debug.log");
+try {
+  mkdirSync(dirname(LOG_FILE), { recursive: true });
+} catch {
+}
+var streams = [
+  { stream: pino.destination(2) },
+  // stderr - CRITICAL: MCP uses stdout for protocol
+  { stream: pino.destination(LOG_FILE) }
+  // file for debugging
+];
+var logger = pino(
+  {
+    level: serverConfig.LOG_LEVEL,
+    timestamp: pino.stdTimeFunctions.isoTime
+  },
+  pino.multistream(streams)
+);
+
+export {
+  loadEnv,
+  logger
+};

package/apps/server/dist/chunk-JSBRDJBE.js

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};