@harborgroup/my-team 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anthony Hudson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# my-team
+
+Chat with your local Claude Code subscription from a web dashboard, scoped to whatever repo you're working in. Dev-only — no API key required, no production code path.
+
+It drives the official [`@anthropic-ai/claude-agent-sdk`](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk), which spawns your existing `claude` login/subscription. If you're logged in via `claude login`, it just works.
+
+## Setup
+
+In any repo:
+
+```sh
+npx @harborgroup/my-team init
+```
+
+This adds `@harborgroup/my-team` as a devDependency and an `npm run team` script.
+
+## Usage
+
+```sh
+npm run team
+```
+
+Opens a local, token-protected dashboard in your browser (bound to `127.0.0.1` only). If Claude Code isn't installed or logged in yet, you'll see onboarding instructions instead.
+
+Chat runs with this repo as Claude's working directory, and tool calls (file edits, shell commands) are auto-approved via Claude's own safety classifier (`permissionMode: 'auto'`) rather than prompted per action — there's no terminal in this flow to answer y/n prompts.
+
+## Status
+
+v1: onboarding + a single chat session per launch. No persisted chat history, no multi-user support.

package/dist/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { runInit } from './init.js';
+import { startServer } from './server/start.js';
+async function main() {
+    if (process.env.NODE_ENV === 'production') {
+        console.error('my-team is a dev-only tool and refuses to run with NODE_ENV=production.');
+        process.exitCode = 1;
+        return;
+    }
+    const [, , command] = process.argv;
+    if (command === 'init') {
+        await runInit(process.cwd());
+    }
+    else {
+        await startServer(process.cwd());
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/dist/init.js

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// dist/init.js -> package root is one level up.
+const OWN_PACKAGE_ROOT = path.join(__dirname, '..');
+const OWN_PACKAGE_JSON = JSON.parse(readFileSync(path.join(OWN_PACKAGE_ROOT, 'package.json'), 'utf-8'));
+function npmInstall(cwd, spec) {
+    // On Windows, npm is a .cmd batch file that spawnSync can't execute
+    // directly (EINVAL). Routing through cmd.exe /c as the actual child
+    // (rather than shell: true) avoids that without the argument-escaping
+    // risk Node warns about (DEP0190) for shell: true + an args array.
+    const result = process.platform === 'win32'
+        ? spawnSync('cmd.exe', ['/d', '/s', '/c', 'npm', 'install', '--save-dev', spec], { cwd, stdio: 'inherit' })
+        : spawnSync('npm', ['install', '--save-dev', spec], { cwd, stdio: 'inherit' });
+    return result.status === 0;
+}
+function addTeamScript(repoPackageJsonPath) {
+    const raw = readFileSync(repoPackageJsonPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    pkg.scripts ??= {};
+    if (pkg.scripts.team) {
+        if (pkg.scripts.team !== 'my-team') {
+            console.warn(`package.json already has a "team" script ("${pkg.scripts.team}") — leaving it untouched. Run "npx my-team" directly instead.`);
+        }
+        return;
+    }
+    pkg.scripts.team = 'my-team';
+    writeFileSync(repoPackageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+    console.log('Added "npm run team" script to package.json.');
+}
+export async function runInit(cwd) {
+    const repoPackageJsonPath = path.join(cwd, 'package.json');
+    const name = OWN_PACKAGE_JSON.name;
+    if (!existsSync(repoPackageJsonPath)) {
+        console.error(`No package.json found at ${cwd}. Run "npm init" first, then re-run "npx ${name} init".`);
+        process.exitCode = 1;
+        return;
+    }
+    const version = OWN_PACKAGE_JSON.version;
+    const installed = npmInstall(cwd, `${name}@${version}`) || npmInstall(cwd, OWN_PACKAGE_ROOT);
+    if (!installed) {
+        console.error('Failed to install my-team as a devDependency.');
+        process.exitCode = 1;
+        return;
+    }
+    addTeamScript(repoPackageJsonPath);
+    console.log('Done — run "npm run team" to launch.');
+}

package/dist/server/auth-check.js

@@ -0,0 +1,45 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { sanitizeEnv } from './env.js';
+/**
+ * Live probe, run fresh on every /api/status call rather than caching an
+ * "onboarded" flag, so it can't go stale.
+ *
+ * Iterating a query() call to completion sends a real, billed model turn
+ * (confirmed empirically) even for an empty prompt. Aborting as soon as the
+ * `system init` message arrives is enough to call accountInfo() without ever
+ * dispatching a turn.
+ */
+export async function checkAuth(cwd) {
+    const controller = new AbortController();
+    const q = query({
+        prompt: '',
+        options: {
+            cwd,
+            env: sanitizeEnv(process.env),
+            permissionMode: 'plan',
+            abortController: controller,
+            maxTurns: 1,
+        },
+    });
+    try {
+        for await (const msg of q) {
+            if (msg.type === 'system' && msg.subtype === 'init') {
+                const accountInfo = await q.accountInfo();
+                controller.abort();
+                if (!accountInfo.email && !accountInfo.apiProvider) {
+                    return { ok: false, reason: 'not-authenticated' };
+                }
+                return { ok: true, accountInfo };
+            }
+        }
+        return { ok: false, reason: 'not-authenticated' };
+    }
+    catch (err) {
+        controller.abort();
+        const message = String(err?.message ?? err);
+        if (/native binary not found|ENOENT|not recognized as an internal/i.test(message)) {
+            return { ok: false, reason: 'cli-missing' };
+        }
+        return { ok: false, reason: 'not-authenticated' };
+    }
+}

package/dist/server/chat-session.js

@@ -0,0 +1,60 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { sanitizeEnv } from './env.js';
+/**
+ * One ongoing SDK session per running server process. Conversation history
+ * lives only in the CLI's own session store (resumed via session_id) — no
+ * disk persistence of our own, lost on server restart (acceptable for v1).
+ */
+export class ChatSession {
+    sessionId;
+    turnInFlight = false;
+    isBusy() {
+        return this.turnInFlight;
+    }
+    async *sendTurn(message, cwd) {
+        if (this.turnInFlight) {
+            yield { type: 'error', message: 'A previous turn is still in progress.' };
+            return;
+        }
+        this.turnInFlight = true;
+        try {
+            const q = query({
+                prompt: message,
+                options: {
+                    cwd,
+                    env: sanitizeEnv(process.env),
+                    permissionMode: 'auto',
+                    ...(this.sessionId ? { resume: this.sessionId } : {}),
+                },
+            });
+            for await (const msg of q) {
+                if (msg.type === 'system' && msg.subtype === 'init') {
+                    this.sessionId = msg.session_id;
+                    yield { type: 'meta', sessionId: msg.session_id };
+                }
+                else if (msg.type === 'assistant') {
+                    for (const block of msg.message.content) {
+                        if (block.type === 'text') {
+                            yield { type: 'text', text: block.text };
+                        }
+                        else if (block.type === 'tool_use') {
+                            yield { type: 'tool-use', name: block.name };
+                        }
+                    }
+                }
+                else if (msg.type === 'result') {
+                    if (msg.subtype !== 'success') {
+                        yield { type: 'error', message: msg.subtype };
+                    }
+                    yield { type: 'done' };
+                }
+            }
+        }
+        catch (err) {
+            yield { type: 'error', message: String(err?.message ?? err) };
+        }
+        finally {
+            this.turnInFlight = false;
+        }
+    }
+}

package/dist/server/env.js

@@ -0,0 +1,12 @@
+/**
+ * Claude Code refuses to start when it detects it's already running inside
+ * another Claude Code session. Strip those markers so `my-team` still works
+ * when launched from a terminal that's itself inside a `claude` session.
+ */
+export function sanitizeEnv(base) {
+    const env = { ...base };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_ENTRYPOINT;
+    delete env.CLAUDE_CODE_SESSION;
+    return env;
+}

package/dist/server/http-server.js

@@ -0,0 +1,94 @@
+import http from 'node:http';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { checkAuth } from './auth-check.js';
+import { ChatSession } from './chat-session.js';
+import { tokensMatch } from './token.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WEB_DIR = path.join(__dirname, '..', 'web');
+const STATIC_FILES = {
+    '/': { file: 'index.html', contentType: 'text/html; charset=utf-8' },
+    '/app.js': { file: 'app.js', contentType: 'text/javascript; charset=utf-8' },
+    '/style.css': { file: 'style.css', contentType: 'text/css; charset=utf-8' },
+};
+function isAllowedHost(hostHeader, port) {
+    if (!hostHeader)
+        return false;
+    return hostHeader === `127.0.0.1:${port}` || hostHeader === `localhost:${port}`;
+}
+function getToken(req, url) {
+    return req.headers['x-my-team-token'] ?? url.searchParams.get('token') ?? undefined;
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    const raw = Buffer.concat(chunks).toString('utf-8');
+    return raw ? JSON.parse(raw) : {};
+}
+export function createServer(options) {
+    const { cwd, token, portRef } = options;
+    const chatSession = new ChatSession();
+    return http.createServer(async (req, res) => {
+        if (!isAllowedHost(req.headers.host, portRef.port)) {
+            res.writeHead(400, { 'Content-Type': 'text/plain' }).end('Bad Host header');
+            return;
+        }
+        const url = new URL(req.url ?? '/', `http://127.0.0.1:${portRef.port}`);
+        const staticEntry = req.method === 'GET' ? STATIC_FILES[url.pathname] : undefined;
+        if (staticEntry) {
+            try {
+                const body = await readFile(path.join(WEB_DIR, staticEntry.file));
+                res.writeHead(200, { 'Content-Type': staticEntry.contentType }).end(body);
+            }
+            catch {
+                res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Not found');
+            }
+            return;
+        }
+        if (!url.pathname.startsWith('/api/')) {
+            res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Not found');
+            return;
+        }
+        if (!tokensMatch(token, getToken(req, url))) {
+            res.writeHead(401, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'unauthorized' }));
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/api/status') {
+            const result = await checkAuth(cwd);
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(result));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/chat') {
+            if (chatSession.isBusy()) {
+                res.writeHead(409, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'busy' }));
+                return;
+            }
+            let message;
+            try {
+                const body = await readJsonBody(req);
+                message = String(body.message ?? '');
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'invalid body' }));
+                return;
+            }
+            if (!message.trim()) {
+                res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: 'empty message' }));
+                return;
+            }
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            });
+            for await (const event of chatSession.sendTurn(message, cwd)) {
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+            res.end();
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Not found');
+    });
+}

package/dist/server/start.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import { createServer } from './http-server.js';
+import { generateToken } from './token.js';
+function openBrowser(url) {
+    const platform = process.platform;
+    try {
+        if (platform === 'win32') {
+            spawn('cmd', ['/c', 'start', '""', url], { shell: false, stdio: 'ignore', detached: true }).unref();
+        }
+        else if (platform === 'darwin') {
+            spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+        }
+        else {
+            spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+        }
+    }
+    catch {
+        // Fall through — the URL is printed to the terminal regardless.
+    }
+}
+export async function startServer(cwd) {
+    const token = generateToken();
+    const portRef = { port: 0 };
+    await new Promise((resolve) => {
+        const server = createServer({ cwd, token, portRef });
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            portRef.port = typeof address === 'object' && address ? address.port : 0;
+            const url = `http://127.0.0.1:${portRef.port}/?token=${token}`;
+            console.log(`my-team is running for ${cwd}`);
+            console.log(`Open: ${url}`);
+            openBrowser(url);
+            resolve();
+        });
+    });
+}

package/dist/server/token.js

@@ -0,0 +1,9 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+export function generateToken() {
+    return randomBytes(32).toString('hex');
+}
+export function tokensMatch(expected, provided) {
+    if (!provided || provided.length !== expected.length)
+        return false;
+    return timingSafeEqual(Buffer.from(expected), Buffer.from(provided));
+}

package/dist/web/app.js

@@ -0,0 +1,118 @@
+const token = new URLSearchParams(location.search).get('token') ?? '';
+
+const el = {
+  loading: document.getElementById('loading'),
+  onboarding: document.getElementById('onboarding'),
+  cliMissing: document.getElementById('onboarding-cli-missing'),
+  notAuthenticated: document.getElementById('onboarding-not-authenticated'),
+  checkAgain: document.getElementById('check-again'),
+  dashboard: document.getElementById('dashboard'),
+  accountLine: document.getElementById('account-line'),
+  messages: document.getElementById('messages'),
+  form: document.getElementById('chat-form'),
+  input: document.getElementById('chat-input'),
+};
+
+function api(path, options = {}) {
+  return fetch(path, {
+    ...options,
+    headers: { ...(options.headers ?? {}), 'X-My-Team-Token': token },
+  });
+}
+
+function show(section) {
+  el.loading.hidden = true;
+  el.onboarding.hidden = section !== 'onboarding';
+  el.dashboard.hidden = section !== 'dashboard';
+}
+
+async function checkStatus() {
+  el.loading.hidden = false;
+  el.onboarding.hidden = true;
+  el.dashboard.hidden = true;
+  const res = await api('/api/status');
+  const result = await res.json();
+
+  if (result.ok) {
+    const info = result.accountInfo;
+    el.accountLine.textContent = `Logged in as ${info.email ?? 'unknown'}${info.subscriptionType ? ` (${info.subscriptionType})` : ''}`;
+    show('dashboard');
+    return;
+  }
+
+  el.cliMissing.hidden = result.reason !== 'cli-missing';
+  el.notAuthenticated.hidden = result.reason !== 'not-authenticated';
+  show('onboarding');
+}
+
+el.checkAgain.addEventListener('click', checkStatus);
+
+function appendMessage(className, text) {
+  const div = document.createElement('div');
+  div.className = `msg ${className}`;
+  div.textContent = text;
+  el.messages.appendChild(div);
+  el.messages.scrollTop = el.messages.scrollHeight;
+  return div;
+}
+
+async function sendMessage(message) {
+  appendMessage('user', message);
+  const assistantEl = appendMessage('assistant', '');
+  let assistantText = '';
+
+  const res = await api('/api/chat', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ message }),
+  });
+
+  if (!res.ok || !res.body) {
+    appendMessage('error', `Request failed (${res.status})`);
+    return;
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    let sepIndex;
+    while ((sepIndex = buffer.indexOf('\n\n')) !== -1) {
+      const frame = buffer.slice(0, sepIndex);
+      buffer = buffer.slice(sepIndex + 2);
+      const line = frame.split('\n').find((l) => l.startsWith('data: '));
+      if (!line) continue;
+      const event = JSON.parse(line.slice('data: '.length));
+
+      if (event.type === 'text') {
+        assistantText += event.text;
+        assistantEl.textContent = assistantText;
+      } else if (event.type === 'tool-use') {
+        appendMessage('tool', `\u{1F527} using tool: ${event.name}`);
+      } else if (event.type === 'error') {
+        appendMessage('error', event.message);
+      }
+    }
+  }
+}
+
+el.form.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  const message = el.input.value.trim();
+  if (!message) return;
+  el.input.value = '';
+  el.input.disabled = true;
+  try {
+    await sendMessage(message);
+  } finally {
+    el.input.disabled = false;
+    el.input.focus();
+  }
+});
+
+checkStatus();

package/dist/web/index.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>my-team</title>
+  <link rel="stylesheet" href="/style.css" />
+</head>
+<body>
+  <main id="app">
+    <p id="loading">Checking Claude Code status&hellip;</p>
+
+    <section id="onboarding" hidden>
+      <h1>Set up Claude Code</h1>
+      <div id="onboarding-cli-missing" hidden>
+        <p>The Claude Code CLI binary couldn't be found or run.</p>
+        <p>Try installing it globally, then reload this page:</p>
+        <pre>npm install -g @anthropic-ai/claude-code</pre>
+      </div>
+      <div id="onboarding-not-authenticated" hidden>
+        <p>Claude Code isn't logged in yet. In a terminal, run:</p>
+        <pre>claude login</pre>
+        <p>Then come back here.</p>
+      </div>
+      <button id="check-again">Check again</button>
+    </section>
+
+    <section id="dashboard" hidden>
+      <header>
+        <span id="account-line"></span>
+      </header>
+      <div class="banner">
+        Tool actions (file edits, shell commands) are auto-approved by Claude's own safety classifier &mdash;
+        not reviewed by you turn-by-turn.
+      </div>
+      <div id="messages"></div>
+      <form id="chat-form">
+        <input id="chat-input" type="text" placeholder="Ask Claude about this repo&hellip;" autocomplete="off" />
+        <button type="submit">Send</button>
+      </form>
+    </section>
+  </main>
+  <script src="/app.js"></script>
+</body>
+</html>

package/dist/web/style.css

@@ -0,0 +1,130 @@
+:root {
+  color-scheme: light dark;
+  --fg: #1a1a1a;
+  --bg: #ffffff;
+  --muted: #666;
+  --border: #ddd;
+  --accent: #2563eb;
+  --banner-bg: #fff7e6;
+  --banner-fg: #7a4a00;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --fg: #eee;
+    --bg: #1a1a1a;
+    --muted: #999;
+    --border: #333;
+    --accent: #60a5fa;
+    --banner-bg: #3a2e0f;
+    --banner-fg: #f0c979;
+  }
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: system-ui, -apple-system, sans-serif;
+  color: var(--fg);
+  background: var(--bg);
+}
+
+#app {
+  max-width: 720px;
+  margin: 0 auto;
+  padding: 2rem 1rem;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+pre {
+  background: color-mix(in srgb, var(--fg) 6%, transparent);
+  padding: 0.75rem 1rem;
+  border-radius: 6px;
+  overflow-x: auto;
+}
+
+.banner {
+  background: var(--banner-bg);
+  color: var(--banner-fg);
+  padding: 0.6rem 0.9rem;
+  border-radius: 6px;
+  font-size: 0.85rem;
+  margin-bottom: 1rem;
+}
+
+#dashboard {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
+}
+
+header {
+  margin-bottom: 0.5rem;
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+#messages {
+  flex: 1;
+  overflow-y: auto;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 1rem;
+  margin-bottom: 1rem;
+}
+
+.msg {
+  margin-bottom: 0.75rem;
+  white-space: pre-wrap;
+  line-height: 1.4;
+}
+
+.msg.user {
+  font-weight: 600;
+}
+
+.msg.tool {
+  color: var(--muted);
+  font-style: italic;
+  font-size: 0.85rem;
+}
+
+.msg.error {
+  color: #d33;
+}
+
+#chat-form {
+  display: flex;
+  gap: 0.5rem;
+}
+
+#chat-input {
+  flex: 1;
+  padding: 0.6rem 0.8rem;
+  border-radius: 6px;
+  border: 1px solid var(--border);
+  background: var(--bg);
+  color: var(--fg);
+  font-size: 1rem;
+}
+
+button {
+  padding: 0.6rem 1.2rem;
+  border-radius: 6px;
+  border: none;
+  background: var(--accent);
+  color: white;
+  font-size: 1rem;
+  cursor: pointer;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: default;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@harborgroup/my-team",
+  "version": "0.1.0",
+  "description": "Chat with your local Claude Code subscription from a web dashboard, scoped to the current repo. Dev-only.",
+  "type": "module",
+  "bin": {
+    "my-team": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-web-assets.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.201",
+    "@anthropic-ai/sdk": "^0.110.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "typescript": "^6.0.3"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthonyhudson-hg/my-team.git"
+  },
+  "homepage": "https://github.com/anthonyhudson-hg/my-team#readme",
+  "bugs": {
+    "url": "https://github.com/anthonyhudson-hg/my-team/issues"
+  }
+}