@nimrobo/mcporter-remote 0.1.0

package/scripts/committer

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+# Disable glob expansion to handle brackets in file paths
+set -f
+usage() {
+  printf 'Usage: %s "commit message" "file" ["file" ...]\n' "$(basename "$0")" >&2
+  exit 2
+}
+
+if [ "$#" -lt 2 ]; then
+  usage
+fi
+
+commit_message=$1
+shift
+
+if [[ "$commit_message" != *[![:space:]]* ]]; then
+  printf 'Error: commit message must not be empty\n' >&2
+  exit 1
+fi
+
+if [ -e "$commit_message" ]; then
+  printf 'Error: first argument looks like a file path ("%s"); provide the commit message first\n' "$commit_message" >&2
+  exit 1
+fi
+
+if [ "$#" -eq 0 ]; then
+  usage
+fi
+
+files=("$@")
+
+for file in "${files[@]}"; do
+  if [ ! -e "$file" ]; then
+    if ! git ls-files --error-unmatch -- "$file" >/dev/null 2>&1; then
+      printf 'Error: file not found: %s\n' "$file" >&2
+      exit 1
+    fi
+  fi
+done
+
+git restore --staged :/
+git add --force -- "${files[@]}"
+
+if git diff --staged --quiet; then
+  printf 'Warning: no staged changes detected for: %s\n' "${files[*]}" >&2
+  exit 1
+fi
+
+git commit -m "$commit_message" -- "${files[@]}"
+
+printf 'Committed "%s" with %d files\n' "$commit_message" "${#files[@]}"

package/scripts/docs-list.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env tsx
+
+import { readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { compact } from 'es-toolkit';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DOCS_DIR = join(__dirname, '..', 'docs');
+
+const EXCLUDED_DIRS = new Set(['archive', 'research']);
+
+function walkMarkdownFiles(dir: string, base: string = dir): string[] {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) {
+      continue;
+    }
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+      files.push(...walkMarkdownFiles(fullPath, base));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      files.push(relative(base, fullPath));
+    }
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+function extractMetadata(fullPath: string): {
+  summary: string | null;
+  readWhen: string[];
+  error?: string;
+} {
+  const content = readFileSync(fullPath, 'utf8');
+
+  if (!content.startsWith('---')) {
+    return { summary: null, readWhen: [], error: 'missing front matter' };
+  }
+
+  const endIndex = content.indexOf('\n---', 3);
+  if (endIndex === -1) {
+    return { summary: null, readWhen: [], error: 'unterminated front matter' };
+  }
+
+  const frontMatter = content.slice(3, endIndex).trim();
+  const lines = frontMatter.split('\n');
+
+  let summaryLine: string | null = null;
+  const readWhen: string[] = [];
+  let collectingField: 'read_when' | null = null;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+
+    if (line.startsWith('summary:')) {
+      summaryLine = line;
+      collectingField = null;
+      continue;
+    }
+
+    if (line.startsWith('read_when:')) {
+      collectingField = 'read_when';
+      const inline = line.slice('read_when:'.length).trim();
+      if (inline.startsWith('[') && inline.endsWith(']')) {
+        try {
+          const parsed = JSON.parse(inline.replace(/'/g, '"')) as unknown;
+          if (Array.isArray(parsed)) {
+            readWhen.push(...compact(parsed.map((item) => String(item).trim())));
+          }
+        } catch {
+          // ignore malformed inline arrays
+        }
+      }
+      continue;
+    }
+
+    if (collectingField === 'read_when') {
+      if (line.startsWith('- ')) {
+        const hint = line.slice(2).trim();
+        if (hint) {
+          readWhen.push(hint);
+        }
+      } else if (line === '') {
+      } else {
+        collectingField = null;
+      }
+    }
+  }
+
+  if (!summaryLine) {
+    return { summary: null, readWhen, error: 'summary key missing' };
+  }
+
+  const summaryValue = summaryLine.slice('summary:'.length).trim();
+  const normalized = summaryValue
+    .replace(/^['"]|['"]$/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  if (!normalized) {
+    return { summary: null, readWhen, error: 'summary is empty' };
+  }
+
+  return { summary: normalized, readWhen };
+}
+
+console.log('Listing all markdown files in docs folder:');
+
+const markdownFiles = walkMarkdownFiles(DOCS_DIR);
+
+for (const relativePath of markdownFiles) {
+  const fullPath = join(DOCS_DIR, relativePath);
+  const { summary, readWhen, error } = extractMetadata(fullPath);
+  if (summary) {
+    console.log(`${relativePath} - ${summary}`);
+    if (readWhen.length > 0) {
+      console.log(`  Read when: ${readWhen.join('; ')}`);
+    }
+  } else {
+    const reason = error ? ` - [${error}]` : '';
+    console.log(`${relativePath}${reason}`);
+  }
+}
+
+console.log(
+  '\nReminder: keep docs up to date as behavior changes. When your task matches any "Read when" hint above (React hooks, cache directives, database work, tests, etc.), read that doc before coding, and suggest new coverage when it is missing.'
+);

package/scripts/generate-json-schema.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env tsx
+
+/**
+ * Generate JSON Schema from Zod schemas using Zod v4's native toJSONSchema() method.
+ * Run with: pnpm generate:schema
+ */
+
+import { writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { RawConfigSchema } from '../src/config-schema.js';
+
+export const CONFIG_SCHEMA_ID = 'https://raw.githubusercontent.com/steipete/mcporter/main/mcporter.schema.json';
+export const CONFIG_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
+
+export function buildConfigJsonSchema(): Record<string, unknown> {
+  const jsonSchema = RawConfigSchema.toJSONSchema({
+    override(ctx) {
+      const schema = ctx.jsonSchema;
+      // Disallow additional properties on objects for stricter validation
+      if (schema?.type === 'object' && schema.additionalProperties === undefined) {
+        schema.additionalProperties = false;
+      }
+    },
+  });
+
+  // Allow $schema property in config files for IDE support
+  if (jsonSchema.properties && typeof jsonSchema.properties === 'object') {
+    (jsonSchema.properties as Record<string, unknown>).$schema = {
+      type: 'string',
+      description: 'JSON Schema URL for IDE validation and autocomplete',
+    };
+  }
+
+  return {
+    ...jsonSchema,
+    $id: CONFIG_SCHEMA_ID,
+    $schema: CONFIG_SCHEMA_DRAFT,
+  };
+}
+
+export function writeConfigJsonSchema(outputPath = 'mcporter.schema.json'): void {
+  const schema = buildConfigJsonSchema();
+  writeFileSync(outputPath, `${JSON.stringify(schema, null, 2)}\n`);
+  console.log(`Generated: ${outputPath}`);
+}
+
+const entryPath = process.argv[1];
+if (entryPath && fileURLToPath(import.meta.url) === entryPath) {
+  writeConfigJsonSchema();
+}

package/scripts/git-policy.ts

@@ -0,0 +1,165 @@
+import { resolve } from 'node:path';
+
+export type GitInvocation = {
+  index: number;
+  argv: string[];
+};
+
+export type GitCommandInfo = {
+  name: string;
+  index: number;
+};
+
+export type GitExecutionContext = {
+  invocation: GitInvocation | null;
+  command: GitCommandInfo | null;
+  subcommand: string | null;
+  workDir: string;
+};
+
+export type GitPolicyEvaluation = {
+  requiresCommitHelper: boolean;
+  requiresExplicitConsent: boolean;
+  isDestructive: boolean;
+};
+
+const COMMIT_HELPER_SUBCOMMANDS = new Set(['add', 'commit']);
+const GUARDED_SUBCOMMANDS = new Set(['push', 'pull', 'merge', 'rebase', 'cherry-pick']);
+const DESTRUCTIVE_SUBCOMMANDS = new Set([
+  'reset',
+  'checkout',
+  'clean',
+  'restore',
+  'switch',
+  'stash',
+  'branch',
+  'filter-branch',
+  'fast-import',
+]);
+
+export function extractGitInvocation(commandArgs: string[]): GitInvocation | null {
+  for (const [index, token] of commandArgs.entries()) {
+    if (token === 'git' || token.endsWith('/git')) {
+      return { index, argv: commandArgs.slice(index) };
+    }
+  }
+  return null;
+}
+
+export function findGitSubcommand(commandArgs: string[]): GitCommandInfo | null {
+  if (commandArgs.length <= 1) {
+    return null;
+  }
+
+  const optionsWithValue = new Set(['-C', '--git-dir', '--work-tree', '-c']);
+  let index = 1;
+
+  while (index < commandArgs.length) {
+    const token = commandArgs[index];
+    if (token === undefined) {
+      break;
+    }
+    if (token === '--') {
+      const next = commandArgs[index + 1];
+      return next ? { name: next, index: index + 1 } : null;
+    }
+    if (!token.startsWith('-')) {
+      return { name: token, index };
+    }
+    if (token.includes('=')) {
+      index += 1;
+      continue;
+    }
+    if (optionsWithValue.has(token)) {
+      index += 2;
+      continue;
+    }
+    index += 1;
+  }
+  return null;
+}
+
+export function determineGitWorkdir(baseDir: string, gitArgs: string[], command: GitCommandInfo | null): string {
+  let workDir = baseDir;
+  const limit = command ? command.index : gitArgs.length;
+  let index = 1;
+
+  while (index < limit) {
+    const token = gitArgs[index];
+    if (token === undefined) {
+      break;
+    }
+    if (token === '-C') {
+      const next = gitArgs[index + 1];
+      if (next) {
+        workDir = resolve(workDir, next);
+      }
+      index += 2;
+      continue;
+    }
+    if (token.startsWith('-C')) {
+      const pathSegment = token.slice(2);
+      if (pathSegment.length > 0) {
+        workDir = resolve(workDir, pathSegment);
+      }
+    }
+    index += 1;
+  }
+
+  return workDir;
+}
+
+export function analyzeGitExecution(commandArgs: string[], workspaceDir: string): GitExecutionContext {
+  const invocation = extractGitInvocation(commandArgs);
+  const command = invocation ? findGitSubcommand(invocation.argv) : null;
+  const workDir = invocation ? determineGitWorkdir(workspaceDir, invocation.argv, command) : workspaceDir;
+
+  return {
+    invocation,
+    command,
+    subcommand: command?.name ?? null,
+    workDir,
+  };
+}
+
+export function requiresCommitHelper(subcommand: string | null): boolean {
+  if (!subcommand) {
+    return false;
+  }
+  return COMMIT_HELPER_SUBCOMMANDS.has(subcommand);
+}
+
+export function requiresExplicitGitConsent(subcommand: string | null): boolean {
+  if (!subcommand) {
+    return false;
+  }
+  return GUARDED_SUBCOMMANDS.has(subcommand);
+}
+
+export function isDestructiveGitSubcommand(command: GitCommandInfo | null, gitArgv: string[]): boolean {
+  if (!command) {
+    return false;
+  }
+
+  const subcommand = command.name;
+  if (DESTRUCTIVE_SUBCOMMANDS.has(subcommand)) {
+    return true;
+  }
+
+  if (subcommand === 'bisect') {
+    const action = gitArgv[command.index + 1] ?? '';
+    return action === 'reset';
+  }
+
+  return false;
+}
+
+export function evaluateGitPolicies(context: GitExecutionContext): GitPolicyEvaluation {
+  const invocationArgv = context.invocation?.argv;
+  const normalizedArgv = Array.isArray(invocationArgv) ? invocationArgv : [];
+  return {
+    requiresCommitHelper: requiresCommitHelper(context.subcommand),
+    requiresExplicitConsent: requiresExplicitGitConsent(context.subcommand),
+    isDestructive: isDestructiveGitSubcommand(context.command, normalizedArgv),
+  };
+}

package/scripts/mcp_signoz_retry_patch.cjs

@@ -0,0 +1,9 @@
+// No-op hook retained for compatibility with the Sweetistics configuration.
+// Signoz MCP occasionally retries on transient errors; keeping this module
+// allows `NODE_OPTIONS=--require=./scripts/mcp_signoz_retry_patch.cjs` to load
+// without throwing if teams reuse the same entry.
+
+module.exports = {
+  // Export a no-op hook so consumers can keep requiring this patch file safely.
+  onRetry() {},
+};

package/scripts/release.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# mcporter release helper
+# - Runs under the guardrail runner by default (MCP_RUNNER or ./runner)
+# - Organized into phases so you can resume after fixing an issue: gates, artifacts, publish, smoke, tag
+# - Stops on the first error (set -euo pipefail)
+
+RUNNER="${MCP_RUNNER:-./runner}"
+VERSION="${VERSION:-$(node -p "require('./package.json').version")}" 
+
+banner() { printf "\n==== %s ====" "$1"; printf "\n"; }
+run() { echo ">> $*"; "$@"; }
+
+phase_gates() {
+  banner "Gates (lint/type/test/build)"
+  run "$RUNNER" pnpm check
+  run "$RUNNER" pnpm test
+  run "$RUNNER" pnpm build
+  run "$RUNNER" pnpm build:bun
+}
+
+phase_artifacts() {
+  banner "Artifacts (tarball + checksums)"
+  local bun_tar="dist-bun/mcporter-macos-arm64-v${VERSION}.tar.gz"
+  run tar -C dist-bun -czf "$bun_tar" mcporter
+  run shasum -a 256 "$bun_tar" | tee "${bun_tar}.sha256"
+
+  run "$RUNNER" npm pack --pack-destination /tmp
+  mv "/tmp/mcporter-${VERSION}.tgz" .
+  run shasum "mcporter-${VERSION}.tgz" > "mcporter-${VERSION}.tgz.sha1"
+  run shasum -a 256 "mcporter-${VERSION}.tgz" > "mcporter-${VERSION}.tgz.sha256"
+}
+
+phase_publish() {
+  banner "Publish to npm"
+  run "$RUNNER" pnpm publish --tag latest
+  run "$RUNNER" npm view mcporter version
+  run "$RUNNER" npm view mcporter time
+}
+
+phase_smoke() {
+  banner "Smoke test in empty dir"
+  local tmp=/tmp/mcporter-empty
+  rm -rf "$tmp" && mkdir -p "$tmp"
+  ( cd "$tmp" && npx mcporter@"$VERSION" generate-cli "npx -y chrome-devtools-mcp" --compile && ./chrome-devtools-mcp --help | head -n 5 )
+}
+
+phase_tag() {
+  banner "Tag and push"
+  git tag "v${VERSION}"
+  git push --tags
+}
+
+usage() {
+  cat <<'EOF'
+Usage: scripts/release.sh [phase]
+
+Phases (run individually or all):
+  gates      pnpm check, test, build, build:bun
+  artifacts  tar + shasum for bun binary; npm pack + shasums
+  publish    pnpm publish --tag latest, verify npm view
+  smoke      empty-dir npx compile + help banner
+  tag        git tag v<version> && push tags
+  all        run everything in order
+
+Environment:
+  MCP_RUNNER (default ./runner) - guardrail wrapper
+  VERSION    (default from package.json)
+EOF
+}
+
+main() {
+  local phase="${1:-all}"
+  case "$phase" in
+    gates) phase_gates ;;
+    artifacts) phase_artifacts ;;
+    publish) phase_publish ;;
+    smoke) phase_smoke ;;
+    tag) phase_tag ;;
+    all) phase_gates; phase_artifacts; phase_publish; phase_smoke; phase_tag ;;
+    *) usage; exit 1 ;;
+  esac
+}
+
+main "$@"