@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-ios-qa/daemon/src/proxy.ts

@@ -1,160 +0,0 @@
-// Tailnet → USB proxy. When an authenticated request hits the tailnet
-// listener and clears capability + allowlist checks, the daemon forwards it
-// to the iOS StateServer over the device's CoreDevice IPv6 tunnel, injecting
-// the rotated boot token in Authorization: Bearer and preserving the
-// X-Session-Id from the caller.
-
-import { request as httpRequest } from 'http';
-import type { IncomingMessage } from 'http';
-import { sanitizeReplacer } from './audit';
-import { tierForRoute } from './types';
-
-const MAX_BODY = 1_048_576; // 1MB hard cap on tailnet ingress
-// Hard cap on one upstream response held in memory (a full-resolution
-// screenshot is well under this). Larger responses fail instead of growing
-// the daemon without bound.
-export const MAX_RESPONSE_BODY = 64 * 1_048_576;
-export const DEFAULT_PROXY_TIMEOUT_MS = 30_000;
-
-export interface DeviceTunnel {
-  udid: string;
-  ipv6Addr: string;
-  port: number;
-  bootTokenRotated: string; // the rotated bearer the daemon uses to talk to StateServer
-}
-
-export interface ProxyError {
-  status: number;
-  body: Record<string, unknown>;
-}
-
-/**
- * Forward a parsed inbound request to the StateServer. Returns the upstream
- * response or a ProxyError. Caller writes to the ServerResponse.
- */
-export async function proxyToDevice(opts: {
-  inbound: IncomingMessage;
-  body: Buffer;
-  tunnel: DeviceTunnel;
-  sessionId: string | null;
-  agentIdentity?: string;
-  /** Wall-clock deadline for the whole response (headers and body), not an idle timer. */
-  timeoutMs?: number;
-  maxResponseBytes?: number;
-}): Promise<{ status: number; headers: Record<string, string>; body: Buffer }> {
-  const { inbound, body, tunnel, sessionId, agentIdentity } = opts;
-  if (body.length > MAX_BODY) {
-    return makeError(413, 'body_too_large');
-  }
-
-  const headers: Record<string, string> = {
-    'authorization': `Bearer ${tunnel.bootTokenRotated}`,
-    'content-type': inbound.headers['content-type'] || 'application/json',
-    'content-length': String(body.length),
-  };
-  if (sessionId) headers['x-session-id'] = sessionId;
-  if (agentIdentity) headers['x-agent-identity'] = agentIdentity;
-
-  // Bracket IPv6 literals; pass IPv4 + hostnames bare. The CoreDevice tunnel
-  // is always IPv6 in production, but tests inject 127.0.0.1 to talk to a
-  // local stub. Detect by `:` count (IPv6 has multiple colons) or `:` absence
-  // (IPv4/hostname).
-  const isIPv6 = (tunnel.ipv6Addr.match(/:/g)?.length ?? 0) >= 2;
-  const hostPart = isIPv6 ? `[${tunnel.ipv6Addr}]` : tunnel.ipv6Addr;
-  const url = `http://${hostPart}:${tunnel.port}${inbound.url ?? '/'}`;
-  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BODY;
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let response: IncomingMessage | undefined;
-    let received = 0;
-    const chunks: Buffer[] = [];
-    const finish = (result: Awaited<ReturnType<typeof proxyToDevice>> | Error, destroy = false) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      response?.off('data', onData);
-      response?.off('end', onEnd);
-      response?.off('aborted', onAborted);
-      chunks.length = 0;
-      if (destroy) req.destroy();
-      if (result instanceof Error) reject(result);
-      else resolve(result);
-    };
-    const onError = (err: Error) => {
-      const e = err as { code?: string };
-      if (e.code === 'ECONNREFUSED' || e.code === 'EHOSTUNREACH') {
-        finish(makeError(503, 'device_disconnected'), true);
-      } else if (e.code === 'ETIMEDOUT') {
-        finish(makeError(504, 'upstream_timeout'), true);
-      } else {
-        finish(err, true);
-      }
-    };
-    const onAborted = () => onError(Object.assign(new Error('Upstream response aborted'), { code: 'ECONNRESET' }));
-    const tooLarge = () => finish(makeError(502, 'upstream_response_too_large'), true);
-    const onData = (chunk: Buffer) => {
-      received += chunk.length;
-      if (received > maxResponseBytes) tooLarge();
-      else chunks.push(chunk);
-    };
-    const onEnd = () => {
-      const respHeaders: Record<string, string> = {};
-      for (const [k, v] of Object.entries(response!.headers)) {
-        if (typeof v === 'string') respHeaders[k] = v;
-      }
-      finish({
-        status: response!.statusCode ?? 502,
-        headers: respHeaders,
-        body: Buffer.concat(chunks),
-      });
-    };
-    const req = httpRequest(url, { method: inbound.method, headers }, (res) => {
-      response = res;
-      res.on('error', onError);
-      res.once('close', () => {
-        if (!settled) onAborted();
-        res.off('error', onError);
-      });
-      if (settled) {
-        res.destroy();
-        return;
-      }
-      if (Number(res.headers['content-length'] ?? 0) > maxResponseBytes) {
-        tooLarge();
-        return;
-      }
-      res.on('data', onData);
-      res.once('end', onEnd);
-      res.once('aborted', onAborted);
-    });
-    const deadline = setTimeout(() => finish(makeError(504, 'upstream_timeout'), true), opts.timeoutMs ?? DEFAULT_PROXY_TIMEOUT_MS);
-    req.on('error', onError);
-    req.once('close', () => {
-      if (!settled && !response) onAborted();
-      req.off('error', onError);
-    });
-    req.write(body);
-    req.end();
-  });
-}
-
-function makeError(status: number, error: string): { status: number; headers: Record<string, string>; body: Buffer } {
-  const body = Buffer.from(JSON.stringify({ error }, sanitizeReplacer));
-  return {
-    status,
-    headers: { 'content-type': 'application/json', 'content-length': String(body.length) },
-    body,
-  };
-}
-
-/**
- * Determine whether the endpoint is allowed on the tailnet listener AND what
- * capability tier it requires.
- */
-export function classifyRoute(method: string, path: string): {
-  allowed: boolean;
-  requiredCapability: ReturnType<typeof tierForRoute>;
-} {
-  const tier = tierForRoute(method, path);
-  return { allowed: tier !== null, requiredCapability: tier };
-}

package/.agent/skills/gstack-ios-qa/daemon/src/session-tokens.ts

@@ -1,126 +0,0 @@
-// Short-lived session token store. In-memory only (never disk). Refreshable
-// via /session/heartbeat. Listable and revokable from loopback listener.
-
-import { randomBytes } from 'crypto';
-import type { Capability, SessionToken } from './types';
-import { capabilityCovers } from './types';
-
-const TOKEN_BYTES = 32; // 256-bit
-const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1h per D9
-const MAX_TTL_MS = 24 * 60 * 60 * 1000; // 24h hard cap
-
-export class SessionTokenStore {
-  private tokens = new Map<string, SessionToken>();
-  private mintsPerIdentity = new Map<string, number[]>(); // ts (ms) for rate limiting
-
-  constructor(
-    private now: () => number = () => Date.now(),
-  ) {}
-
-  /**
-   * Mint a session token. Returns null on rate limit.
-   */
-  mint(opts: {
-    identity: string;
-    capability: Capability;
-    ttlMs?: number;
-    deviceUdid?: string | null;
-    origin: SessionToken['origin'];
-  }): SessionToken | { error: 'rate_limited' } {
-    if (!this.checkRateLimit(opts.identity)) {
-      return { error: 'rate_limited' };
-    }
-    const ttl = Math.min(opts.ttlMs ?? DEFAULT_TTL_MS, MAX_TTL_MS);
-    const token = randomBytes(TOKEN_BYTES).toString('base64url');
-    const expires_at = this.now() + ttl;
-    const session: SessionToken = {
-      token,
-      identity: opts.identity,
-      capability: opts.capability,
-      expires_at,
-      device_udid: opts.deviceUdid ?? null,
-      origin: opts.origin,
-    };
-    this.tokens.set(token, session);
-    return session;
-  }
-
-  /**
-   * Validate a token. Returns the session if valid (token exists, not
-   * expired). Otherwise returns null with a reason for the audit log.
-   */
-  validate(token: string | null | undefined, need: Capability):
-    | { ok: true; session: SessionToken }
-    | { ok: false; reason: 'no_token' | 'invalid_token' | 'expired_token' | 'capability_insufficient' } {
-    if (!token) return { ok: false, reason: 'no_token' };
-    const s = this.tokens.get(token);
-    if (!s) return { ok: false, reason: 'invalid_token' };
-    if (s.expires_at < this.now()) {
-      this.tokens.delete(token);
-      return { ok: false, reason: 'expired_token' };
-    }
-    if (!capabilityCovers(s.capability, need)) {
-      return { ok: false, reason: 'capability_insufficient' };
-    }
-    return { ok: true, session: s };
-  }
-
-  /**
-   * Slide token expiry forward by ttlMs. Caps at the token's original max
-   * (which itself is bounded by MAX_TTL_MS). Returns the new expiry.
-   */
-  heartbeat(token: string, ttlMs?: number): number | null {
-    const s = this.tokens.get(token);
-    if (!s) return null;
-    if (s.expires_at < this.now()) {
-      this.tokens.delete(token);
-      return null;
-    }
-    const newExpiry = this.now() + Math.min(ttlMs ?? DEFAULT_TTL_MS, MAX_TTL_MS);
-    s.expires_at = newExpiry;
-    return newExpiry;
-  }
-
-  revoke(token: string): boolean {
-    return this.tokens.delete(token);
-  }
-
-  revokeByIdentity(identity: string): number {
-    let count = 0;
-    for (const [token, s] of this.tokens) {
-      if (s.identity === identity) {
-        this.tokens.delete(token);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  list(): SessionToken[] {
-    return [...this.tokens.values()];
-  }
-
-  // For tests: clear all state.
-  reset() {
-    this.tokens.clear();
-    this.mintsPerIdentity.clear();
-  }
-
-  /**
-   * Rate limit: 10 mints / 60s per identity. Sliding window.
-   */
-  private checkRateLimit(identity: string): boolean {
-    const now = this.now();
-    const window = 60_000;
-    const limit = 10;
-    const hits = this.mintsPerIdentity.get(identity) ?? [];
-    const recent = hits.filter(t => now - t < window);
-    if (recent.length >= limit) {
-      this.mintsPerIdentity.set(identity, recent);
-      return false;
-    }
-    recent.push(now);
-    this.mintsPerIdentity.set(identity, recent);
-    return true;
-  }
-}

package/.agent/skills/gstack-ios-qa/daemon/src/single-instance.ts

@@ -1,171 +0,0 @@
-// Single-instance enforcement. Daemon takes an exclusive flock on
-// ~/.gstack/ios-qa-daemon.pid on startup. Second invocation discovers the
-// existing daemon's port + connects. Stale lock (PID dead) is reclaimed.
-//
-// Readiness protocol: daemon writes `READY: port=<n> pid=<pid>` to stdout
-// once both listeners are up; the spawner reads stdout with a 5s timeout.
-
-import { readFile, mkdir, unlink } from 'fs/promises';
-import { existsSync, openSync, writeSync, closeSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
-import { spawn } from 'child_process';
-import { resolveStateRoot } from '../../../lib/state-root';
-
-export interface PidfileContents {
-  pid: number;
-  port: number;
-  startedAt: number;
-}
-
-export function defaultPidfilePath(): string {
-  return process.env.GSTACK_IOS_DAEMON_PIDFILE
-    ?? join(resolveStateRoot(), 'ios-qa-daemon.pid');
-}
-
-/**
- * Try to claim the pidfile. Returns:
- * - { claimed: true } when this process now owns the lock
- * - { claimed: false, existing } when another live daemon holds it
- *
- * The "live" check is process.kill(pid, 0): succeeds if the PID exists,
- * fails with ESRCH if not. We DO NOT trust a stale pidfile.
- */
-export async function tryClaim(opts: {
-  port: number;
-  path?: string;
-}): Promise<
-  | { claimed: true; release: () => Promise<void> }
-  | { claimed: false; existing: PidfileContents }
-> {
-  const path = opts.path ?? defaultPidfilePath();
-  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-
-  // Check for an existing pidfile.
-  if (existsSync(path)) {
-    try {
-      const raw = await readFile(path, 'utf-8');
-      const existing = JSON.parse(raw) as PidfileContents;
-      if (isAlive(existing.pid)) {
-        return { claimed: false, existing };
-      }
-      // Stale — drop it and continue to claim.
-      await unlink(path).catch(() => {});
-    } catch {
-      // Unparseable pidfile — treat as stale.
-      await unlink(path).catch(() => {});
-    }
-  }
-
-  // Use SYNCHRONOUS open with O_EXCL for atomic exclusion. Bun's async
-  // fs.open(wx) doesn't reliably preserve O_EXCL semantics across concurrent
-  // calls in the same process. Sync openSync goes straight to syscall and is
-  // genuinely atomic.
-  //
-  // Constant 0x800 = O_EXCL on macOS/Linux; combined with O_CREAT (0x200) and
-  // O_WRONLY (0x1) it's the equivalent of 'wx'. The sync API accepts the
-  // string flag form too, but explicit numeric flags are the most defensive.
-  const contents: PidfileContents = {
-    pid: process.pid,
-    port: opts.port,
-    startedAt: Date.now(),
-  };
-  let fd: number;
-  try {
-    fd = openSync(path, 'wx', 0o600);
-  } catch (err: unknown) {
-    const e = err as { code?: string };
-    if (e.code === 'EEXIST') {
-      // Race: another caller won.
-      const raw = await readFile(path, 'utf-8').catch(() => '{}');
-      const existing = JSON.parse(raw || '{}') as PidfileContents;
-      return { claimed: false, existing };
-    }
-    throw err;
-  }
-  try {
-    writeSync(fd, JSON.stringify(contents, null, 2));
-  } finally {
-    closeSync(fd);
-  }
-
-  // Cleanup on exit.
-  const cleanup = async () => {
-    try {
-      // Verify we still own it before unlinking.
-      const raw = await readFile(path, 'utf-8');
-      const cur = JSON.parse(raw) as PidfileContents;
-      if (cur.pid === process.pid) {
-        await unlink(path);
-      }
-    } catch {
-      // best-effort
-    }
-  };
-
-  process.on('exit', () => {
-    try { unlinkSync(path); } catch { /* ignore */ }
-  });
-  process.on('SIGINT', () => { cleanup().finally(() => process.exit(0)); });
-  process.on('SIGTERM', () => { cleanup().finally(() => process.exit(0)); });
-
-  return { claimed: true, release: cleanup };
-}
-
-function isAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err: unknown) {
-    const e = err as { code?: string };
-    return e.code !== 'ESRCH';
-  }
-}
-
-/**
- * Spawn a daemon process and wait for the READY line. Returns the port the
- * daemon claims to be listening on.
- *
- * Used by /ios-qa skill to spawn-on-demand. If another daemon is already
- * running, the spawned child detects the existing pidfile and prints a
- * READY line with the existing port (loaded from the pidfile).
- */
-export async function spawnAndWaitReady(opts: {
-  cmd: string;
-  args: string[];
-  timeoutMs?: number;
-  env?: NodeJS.ProcessEnv;
-}): Promise<{ pid: number; port: number }> {
-  const timeoutMs = opts.timeoutMs ?? 5000;
-  const child = spawn(opts.cmd, opts.args, {
-    stdio: ['ignore', 'pipe', 'inherit'],
-    detached: true,
-    env: opts.env ?? process.env,
-  });
-
-  return new Promise((resolve, reject) => {
-    let buffer = '';
-    const onTimeout = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`daemon spawn timeout after ${timeoutMs}ms`));
-    }, timeoutMs);
-
-    child.stdout?.on('data', (chunk: Buffer) => {
-      buffer += chunk.toString();
-      const match = buffer.match(/READY:\s*port=(\d+)\s+pid=(\d+)/);
-      if (match) {
-        clearTimeout(onTimeout);
-        child.unref();
-        resolve({ pid: parseInt(match[2]!, 10), port: parseInt(match[1]!, 10) });
-      }
-    });
-    child.on('error', (err) => {
-      clearTimeout(onTimeout);
-      reject(err);
-    });
-    child.on('exit', (code, signal) => {
-      clearTimeout(onTimeout);
-      reject(new Error(`daemon exited before READY (code=${code} signal=${signal})`));
-    });
-  });
-}

package/.agent/skills/gstack-ios-qa/daemon/src/tailscale-localapi.ts

@@ -1,120 +0,0 @@
-// tailscaled LocalAPI client. Reads the unix socket at /var/run/tailscale.sock
-// (or wherever tailscaled is listening), calls WhoIs, returns a canonicalized
-// identity string.
-//
-// **Fail-closed semantics:** every error path here MUST be surfaced as a
-// reason the tailnet listener should refuse to open. Daemon caller must
-// distinguish "socket missing" (Tailscale not installed) from "WhoIs returned
-// unparseable response" (Tailscale broken) so the user knows what to fix.
-
-import { request as httpRequest } from 'http';
-import type { WhoIsResult } from './types';
-
-export interface TailscaleProbe {
-  ok: boolean;
-  reason?: 'socket_missing' | 'permission_denied' | 'whois_unparseable' | 'unreachable';
-  ownIdentity?: string;
-}
-
-/**
- * Probe whether tailscaled LocalAPI is usable. Called before opening the
- * tailnet listener. Returns ok=true only if WhoIs against the daemon's own
- * identity returns a parseable result.
- */
-export async function probeTailscale(socketPath: string = '/var/run/tailscale.sock'): Promise<TailscaleProbe> {
-  try {
-    const result = await whoIs('127.0.0.1:9999', socketPath);
-    return { ok: true, ownIdentity: result.identity };
-  } catch (err: unknown) {
-    const e = err as { code?: string; message?: string };
-    if (e.code === 'ENOENT' || (e.message ?? '').includes('ENOENT')) {
-      return { ok: false, reason: 'socket_missing' };
-    }
-    if (e.code === 'EACCES' || (e.message ?? '').includes('EACCES')) {
-      return { ok: false, reason: 'permission_denied' };
-    }
-    if ((e.message ?? '').includes('unparseable') || (e.message ?? '').includes('JSON')) {
-      return { ok: false, reason: 'whois_unparseable' };
-    }
-    return { ok: false, reason: 'unreachable' };
-  }
-}
-
-/**
- * Call /localapi/v0/whois?addr=<addr:port>. Returns canonicalized identity.
- *
- * Canonicalization rules (matches Tailscale convention):
- * - User OAuth: `user@example.com` (no acct: prefix, lowercase email)
- * - Tagged nodes: `tag:<name>` (lowercased)
- * - Node keys: `node:<hex>` (rare, prefer tags)
- */
-export async function whoIs(addr: string, socketPath: string = '/var/run/tailscale.sock'): Promise<WhoIsResult> {
-  return new Promise((resolve, reject) => {
-    const req = httpRequest({
-      socketPath,
-      path: `/localapi/v0/whois?addr=${encodeURIComponent(addr)}`,
-      method: 'GET',
-      headers: { Host: 'local-tailscaled.sock' },
-    }, (res) => {
-      const chunks: Buffer[] = [];
-      res.on('data', (c) => chunks.push(c));
-      res.on('end', () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`whois http ${res.statusCode}`));
-          return;
-        }
-        try {
-          const raw = Buffer.concat(chunks).toString('utf-8');
-          const obj = JSON.parse(raw) as Record<string, unknown>;
-          const identity = canonicalize(obj);
-          if (!identity) {
-            reject(new Error('whois response unparseable'));
-            return;
-          }
-          resolve({ identity, raw: obj });
-        } catch (e) {
-          reject(new Error(`whois response unparseable: ${(e as Error).message}`));
-        }
-      });
-    });
-    req.on('error', reject);
-    req.end();
-  });
-}
-
-/**
- * Reduce a WhoIs response object to a canonical identity string.
- *
- * Expected response shape (Tailscale LocalAPI v0):
- * {
- *   "Node": { "ComputedName": "...", "Tags": ["tag:ci"], ... },
- *   "UserProfile": { "LoginName": "user@example.com", ... },
- * }
- */
-export function canonicalize(obj: Record<string, unknown>): string | null {
-  // Tagged node — tag is more specific than user identity for ACL purposes.
-  const node = obj.Node as Record<string, unknown> | undefined;
-  if (node) {
-    const tags = node.Tags as string[] | undefined;
-    if (Array.isArray(tags) && tags.length > 0 && typeof tags[0] === 'string') {
-      const tag = tags[0].toLowerCase();
-      // Tags from Tailscale are already in `tag:foo` form.
-      return tag.startsWith('tag:') ? tag : `tag:${tag}`;
-    }
-  }
-  const profile = obj.UserProfile as Record<string, unknown> | undefined;
-  if (profile) {
-    const loginName = profile.LoginName as string | undefined;
-    if (typeof loginName === 'string' && loginName.includes('@')) {
-      return loginName.toLowerCase();
-    }
-  }
-  // Fallback to node key — rare but possible.
-  if (node) {
-    const key = node.Key as string | undefined;
-    if (typeof key === 'string' && key.startsWith('nodekey:')) {
-      return `node:${key.replace('nodekey:', '')}`;
-    }
-  }
-  return null;
-}