tmux-ide 2.6.0 → 2.7.0

package/packages/daemon/src/lib/auth/middleware.ts

@@ -0,0 +1,56 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import type { Context, Next, MiddlewareHandler } from "hono";
+import { AuthService } from "./auth-service.ts";
+import type { AuthConfig } from "./types.ts";
+
+/**
+ * Hono middleware that checks Authorization Bearer header.
+ *
+ * - Bypasses /health and /api/auth/* routes.
+ * - When method is "none" (default), passes through everything (backward compatible).
+ * - Otherwise validates the JWT and sets c.set("userId", ...).
+ */
+export function authMiddleware(authService: AuthService, config: AuthConfig): MiddlewareHandler {
+  return async (c: Context, next: Next) => {
+    // Backward compatible: no auth required when method is "none"
+    if (config.method === "none") {
+      return next();
+    }
+
+    const path = new URL(c.req.url).pathname;
+
+    // Bypass health and auth endpoints
+    if (path === "/health" || path.startsWith("/api/auth/")) {
+      return next();
+    }
+
+    const authHeader = c.req.header("Authorization");
+    if (!authHeader?.startsWith("Bearer ")) {
+      return c.json({ error: "Missing or invalid Authorization header" }, 401);
+    }
+
+    const token = authHeader.slice(7);
+    const result = authService.verifyToken(token);
+    if (!result.valid) {
+      return c.json({ error: "Invalid or expired token" }, 401);
+    }
+
+    c.set("userId", result.userId);
+    return next();
+  };
+}
+
+/**
+ * Validate a JWT token from a query parameter (for WebSocket upgrade).
+ * Returns the userId if valid, null otherwise.
+ */
+export function validateWsToken(
+  authService: AuthService,
+  config: AuthConfig,
+  token: string | null,
+): string | null {
+  if (config.method === "none") return "anonymous";
+  if (!token) return null;
+  const result = authService.verifyToken(token);
+  return result.valid ? (result.userId ?? null) : null;
+}

package/packages/daemon/src/lib/auth/types.ts

@@ -0,0 +1,2 @@
+// Schema extracted to @tmux-ide/contracts (T056). Re-export shim.
+export { AuthConfigSchema, type AuthConfig } from "@tmux-ide/contracts";

package/packages/daemon/src/lib/auth-token.ts

@@ -0,0 +1,5 @@
+import { randomBytes } from "node:crypto";
+
+export function generateAuthToken(): string {
+  return randomBytes(32).toString("base64url");
+}

package/packages/daemon/src/lib/authorship.ts

@@ -0,0 +1,280 @@
+/**
+ * Character-range authorship tracking for plan files.
+ *
+ * Follows the @proof/core marks model: each mark tracks authorship at the
+ * character range level with quote-based re-anchoring when positions shift.
+ *
+ * @module authorship
+ */
+
+// ============================================================================
+// Types (following @proof/core marks model)
+// ============================================================================
+
+export type MarkKind =
+  | "authored"
+  | "approved"
+  | "flagged"
+  | "comment"
+  | "insert"
+  | "delete"
+  | "replace";
+
+export interface MarkRange {
+  from: number;
+  to: number;
+}
+
+export interface Mark {
+  id: string;
+  kind: MarkKind;
+  by: string; // "ai:François" or "human:thijs"
+  at: string; // ISO timestamp
+  range: MarkRange; // character positions in the clean content
+  quote: string; // text content for re-anchoring
+  orphaned?: boolean;
+}
+
+export interface MarksDocument {
+  version: number;
+  marks: Record<string, Mark>;
+}
+
+export interface AuthorshipStats {
+  aiPercent: number;
+  humanPercent: number;
+  totalChars: number;
+}
+
+// ============================================================================
+// Comment block format
+// ============================================================================
+
+const MARKS_START = "<!-- TMUX-IDE:MARKS";
+const MARKS_END = "-->";
+
+// ============================================================================
+// ID generation
+// ============================================================================
+
+let markIdCounter = 0;
+
+export function generateMarkId(): string {
+  return `m${Date.now()}_${++markIdCounter}`;
+}
+
+// ============================================================================
+// Quote normalization (matches @proof/core)
+// ============================================================================
+
+export function normalizeQuote(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// ============================================================================
+// Extract / Embed
+// ============================================================================
+
+/**
+ * Extract marks from a markdown file.
+ * Returns clean content (without the comment block) and parsed marks.
+ */
+export function extractMarks(markdown: string): {
+  content: string;
+  marks: MarksDocument | null;
+} {
+  const startIdx = markdown.lastIndexOf(MARKS_START);
+  if (startIdx === -1) {
+    return { content: markdown, marks: null };
+  }
+
+  const endIdx = markdown.indexOf(MARKS_END, startIdx + MARKS_START.length);
+  if (endIdx === -1) {
+    return { content: markdown, marks: null };
+  }
+
+  const jsonStr = markdown.slice(startIdx + MARKS_START.length, endIdx).trim();
+  const content = (
+    markdown.slice(0, startIdx) + markdown.slice(endIdx + MARKS_END.length)
+  ).trimEnd();
+
+  try {
+    const data = JSON.parse(jsonStr) as MarksDocument;
+    return { content, marks: data };
+  } catch {
+    return { content, marks: null };
+  }
+}
+
+/**
+ * Embed marks into a markdown file.
+ * Strips any existing marks comment and appends a new one at the end.
+ */
+export function embedMarks(markdown: string, doc: MarksDocument): string {
+  const { content } = extractMarks(markdown);
+  const json = JSON.stringify(doc, null, 2);
+  return `${content}\n\n${MARKS_START}\n${json}\n${MARKS_END}\n`;
+}
+
+// ============================================================================
+// Mark creation helpers
+// ============================================================================
+
+export function createAuthored(by: string, range: MarkRange, quote: string): Mark {
+  return {
+    id: generateMarkId(),
+    kind: "authored",
+    by,
+    at: new Date().toISOString(),
+    range,
+    quote: normalizeQuote(quote),
+  };
+}
+
+// ============================================================================
+// Stats calculation
+// ============================================================================
+
+/**
+ * Calculate AI vs human authorship percentages from marks.
+ * Only counts 'authored' marks. Uses character range lengths.
+ */
+export function calculateStats(marks: Record<string, Mark>): AuthorshipStats {
+  let aiChars = 0;
+  let humanChars = 0;
+
+  for (const mark of Object.values(marks)) {
+    if (mark.kind !== "authored") continue;
+    if (mark.orphaned) continue;
+    const chars = mark.range.to - mark.range.from;
+    if (mark.by.startsWith("ai:") || mark.by === "ai") {
+      aiChars += chars;
+    } else {
+      humanChars += chars;
+    }
+  }
+
+  const totalChars = aiChars + humanChars;
+  if (totalChars === 0) {
+    return { aiPercent: 0, humanPercent: 0, totalChars: 0 };
+  }
+
+  return {
+    aiPercent: Math.round((aiChars / totalChars) * 100),
+    humanPercent: Math.round((humanChars / totalChars) * 100),
+    totalChars,
+  };
+}
+
+// ============================================================================
+// Re-anchoring: recover positions when content shifts
+// ============================================================================
+
+/**
+ * Find the position of a quote in content text.
+ * Returns { from, to } or null if not found.
+ */
+function findQuotePosition(content: string, quote: string): MarkRange | null {
+  if (!quote) return null;
+  const normalized = normalizeQuote(quote);
+  const normalizedContent = normalizeQuote(content);
+  const idx = normalizedContent.indexOf(normalized);
+  if (idx === -1) return null;
+
+  // Map back to original content positions (approximate — whitespace may differ)
+  // Walk through original content counting normalized chars
+  let origFrom = -1;
+  let normalizedPos = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (/\s/.test(content[i]!) && (i === 0 || /\s/.test(content[i - 1]!))) continue;
+    if (normalizedPos === idx && origFrom === -1) origFrom = i;
+    if (normalizedPos === idx + normalized.length) {
+      return { from: origFrom, to: i };
+    }
+    normalizedPos++;
+  }
+
+  // Fallback: simple indexOf on original
+  const simpleIdx = content.indexOf(quote);
+  if (simpleIdx !== -1) {
+    return { from: simpleIdx, to: simpleIdx + quote.length };
+  }
+
+  return null;
+}
+
+/**
+ * Re-anchor marks whose ranges may have shifted due to content edits.
+ * Uses quote text to find new positions. Marks orphaned if quote not found.
+ */
+export function reanchorMarks(content: string, marks: Record<string, Mark>): Record<string, Mark> {
+  const result: Record<string, Mark> = {};
+
+  for (const [id, mark] of Object.entries(marks)) {
+    // Check if current range still matches quote
+    const currentText = content.slice(mark.range.from, mark.range.to);
+    if (normalizeQuote(currentText) === normalizeQuote(mark.quote)) {
+      result[id] = mark;
+      continue;
+    }
+
+    // Try to re-anchor using quote
+    const newRange = findQuotePosition(content, mark.quote);
+    if (newRange) {
+      result[id] = { ...mark, range: newRange, orphaned: false };
+    } else {
+      result[id] = { ...mark, orphaned: true };
+    }
+  }
+
+  return result;
+}
+
+// ============================================================================
+// Tagging: tag entire content as authored by a given actor
+// ============================================================================
+
+/**
+ * Tag the full content as authored by the given actor.
+ * Preserves existing marks and only adds a mark for uncovered ranges.
+ */
+export function tagContent(markdown: string, by: string): string {
+  const { content, marks: existingDoc } = extractMarks(markdown);
+  const existingMarks = existingDoc?.marks ?? {};
+
+  // Re-anchor existing marks against current content
+  const anchored =
+    Object.keys(existingMarks).length > 0 ? reanchorMarks(content, existingMarks) : {};
+
+  // Find uncovered character ranges
+  const covered = new Set<number>();
+  for (const mark of Object.values(anchored)) {
+    if (mark.kind !== "authored" || mark.orphaned) continue;
+    for (let i = mark.range.from; i < mark.range.to && i < content.length; i++) {
+      covered.add(i);
+    }
+  }
+
+  // Build marks for uncovered ranges (coalesce adjacent)
+  const newMarks: Record<string, Mark> = { ...anchored };
+  let rangeStart = -1;
+
+  for (let i = 0; i <= content.length; i++) {
+    const isCovered = covered.has(i);
+    const atEnd = i === content.length;
+
+    if (!isCovered && !atEnd && rangeStart === -1) {
+      rangeStart = i;
+    } else if ((isCovered || atEnd) && rangeStart !== -1) {
+      const quote = content.slice(rangeStart, i);
+      if (quote.trim().length > 0) {
+        const mark = createAuthored(by, { from: rangeStart, to: i }, quote);
+        newMarks[mark.id] = mark;
+      }
+      rangeStart = -1;
+    }
+  }
+
+  const doc: MarksDocument = { version: 2, marks: newMarks };
+  return embedMarks(content, doc);
+}

package/packages/daemon/src/lib/canonical-daemon.ts

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface CanonicalDaemonInfo {
+  readonly pid: number;
+  readonly port: number;
+  readonly version: string;
+  readonly startedAt: string;
+  readonly bindHostname: string;
+  readonly authToken: string | null;
+}
+
+const DAEMON_INFO_DIR_ENV = "TMUX_IDE_DAEMON_INFO_DIR";
+const REGISTRY_DIR_ENV = "TMUX_IDE_REGISTRY_DIR";
+const DAEMON_INFO_FILE = "daemon.json";
+
+export function getCanonicalDaemonInfoPath(): string {
+  const dir =
+    process.env[DAEMON_INFO_DIR_ENV] ??
+    process.env[REGISTRY_DIR_ENV] ??
+    join(homedir(), ".tmux-ide");
+  return join(dir, DAEMON_INFO_FILE);
+}
+
+function parseCanonicalDaemonInfo(raw: unknown): CanonicalDaemonInfo | null {
+  if (!raw || typeof raw !== "object") return null;
+  const info = raw as Partial<CanonicalDaemonInfo>;
+  const pid = info.pid;
+  const port = info.port;
+  if (typeof pid !== "number" || typeof port !== "number") return null;
+  if (!Number.isInteger(pid) || !Number.isInteger(port)) return null;
+  if (typeof info.version !== "string" || typeof info.startedAt !== "string") return null;
+  if (typeof info.bindHostname !== "string") return null;
+  if (info.authToken !== null && typeof info.authToken !== "string") return null;
+  return {
+    pid,
+    port,
+    version: info.version,
+    startedAt: info.startedAt,
+    bindHostname: info.bindHostname,
+    authToken: info.authToken,
+  };
+}
+
+export function writeCanonicalDaemonInfo(info: CanonicalDaemonInfo): void {
+  const path = getCanonicalDaemonInfoPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const persisted: CanonicalDaemonInfo = {
+    pid: info.pid,
+    port: info.port,
+    version: info.version,
+    startedAt: info.startedAt,
+    bindHostname: info.bindHostname,
+    authToken: info.authToken,
+  };
+  writeFileSync(tmpPath, JSON.stringify(persisted, null, 2) + "\n", "utf-8");
+  renameSync(tmpPath, path);
+}
+
+export function readCanonicalDaemonInfo(): CanonicalDaemonInfo | null {
+  const path = getCanonicalDaemonInfoPath();
+  if (!existsSync(path)) return null;
+  try {
+    return parseCanonicalDaemonInfo(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+
+export function clearCanonicalDaemonInfo(): void {
+  rmSync(getCanonicalDaemonInfoPath(), { force: true });
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function probeHostname(bindHostname: string): string {
+  return bindHostname === "0.0.0.0" ? "127.0.0.1" : bindHostname;
+}
+
+function timeoutSignal(ms: number): AbortSignal {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), ms).unref?.();
+  return controller.signal;
+}
+
+/**
+ * Version-skew guard. A client (desktop app, editor extension, second
+ * CLI) attaching to the canonical daemon compiles in the daemon
+ * version it expects. If the live daemon advertises a different
+ * `version`, the wire contract may have drifted — warn loudly rather
+ * than failing silently on a mismatched action/WS schema.
+ */
+export function warnOnDaemonVersionSkew(info: CanonicalDaemonInfo, expectedVersion: string): void {
+  if (info.version === expectedVersion) return;
+  console.warn(
+    `[tmux-ide] canonical daemon version skew: daemon.json reports ` +
+      `"${info.version}" but this client expects "${expectedVersion}". ` +
+      `The action/WS contract may have drifted — restart the canonical ` +
+      `daemon (tmux-ide) so it matches this client build.`,
+  );
+}
+
+export async function isCanonicalDaemonAlive(info: CanonicalDaemonInfo): Promise<boolean> {
+  if (!isPidAlive(info.pid)) return false;
+  try {
+    const res = await fetch(`http://${probeHostname(info.bindHostname)}:${info.port}/health`, {
+      signal: timeoutSignal(750),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}

package/packages/daemon/src/lib/cli-action-bridge.ts

@@ -0,0 +1,216 @@
+import { createRequire } from "node:module";
+import { z } from "zod";
+import {
+  ActionContractsZ,
+  type ActionInput,
+  type ActionName,
+  type ActionResult,
+} from "../command-center/actions/contract.ts";
+import type { ActionErrorCode } from "../command-center/actions/errors.ts";
+import {
+  clearCanonicalDaemonInfo,
+  isCanonicalDaemonAlive,
+  readCanonicalDaemonInfo,
+  warnOnDaemonVersionSkew,
+  type CanonicalDaemonInfo,
+} from "./canonical-daemon.ts";
+import {
+  startEmbeddedDaemon,
+  type EmbeddedDaemonHandle,
+  type EmbeddedDaemonOptions,
+} from "./daemon-embed.ts";
+
+interface ActionFailure {
+  code: ActionErrorCode;
+  message: string;
+  details?: unknown;
+}
+
+const FailureEnvelopeZ = z.object({
+  ok: z.literal(false),
+  error: z.object({
+    code: z.string(),
+    message: z.string(),
+    details: z.unknown().optional(),
+  }),
+});
+
+interface CliActionBridgeDeps {
+  fetch: typeof fetch;
+  cwd: () => string;
+  readCanonicalDaemonInfo: () => CanonicalDaemonInfo | null;
+  clearCanonicalDaemonInfo: () => void;
+  isCanonicalDaemonAlive: (info: CanonicalDaemonInfo) => Promise<boolean>;
+  startEmbeddedDaemon: (opts: EmbeddedDaemonOptions) => Promise<EmbeddedDaemonHandle>;
+}
+
+let deps: CliActionBridgeDeps = {
+  fetch,
+  cwd: () => process.cwd(),
+  readCanonicalDaemonInfo,
+  clearCanonicalDaemonInfo,
+  isCanonicalDaemonAlive,
+  startEmbeddedDaemon,
+};
+
+export class CliActionInvocationError extends Error {
+  readonly code: ActionErrorCode;
+  readonly details: unknown;
+
+  constructor(error: ActionFailure) {
+    super(error.message);
+    this.name = "CliActionInvocationError";
+    this.code = error.code;
+    this.details = error.details ?? null;
+  }
+}
+
+export function __setCliActionBridgeDepsForTests(
+  overrides: Partial<CliActionBridgeDeps>,
+): () => void {
+  const previous = deps;
+  deps = { ...deps, ...overrides };
+  return () => {
+    deps = previous;
+  };
+}
+
+function timeoutSignal(ms: number): AbortSignal {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), ms).unref?.();
+  return controller.signal;
+}
+
+async function isDaemonAlive(port: number): Promise<boolean> {
+  try {
+    const res = await deps.fetch(`http://127.0.0.1:${port}/health`, {
+      signal: timeoutSignal(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+function hostnameForClient(bindHostname: string): string {
+  return bindHostname === "0.0.0.0" ? "127.0.0.1" : bindHostname;
+}
+
+function daemonBaseUrl(info: CanonicalDaemonInfo): string {
+  return `http://${hostnameForClient(info.bindHostname)}:${info.port}`;
+}
+
+const requireFromHere = createRequire(import.meta.url);
+
+/** The daemon version this CLI client was built against — compared
+ *  against the live daemon's advertised version on attach. */
+function expectedDaemonVersion(): string {
+  try {
+    const pkg = requireFromHere("../../package.json") as { version?: string };
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+async function resolveCanonicalDaemon(): Promise<{
+  baseUrl: string;
+  transientHandle: EmbeddedDaemonHandle | null;
+  restoreCwd: string | null;
+} | null> {
+  const existing = deps.readCanonicalDaemonInfo();
+  if (existing) {
+    if (await deps.isCanonicalDaemonAlive(existing)) {
+      warnOnDaemonVersionSkew(existing, expectedDaemonVersion());
+      return { baseUrl: daemonBaseUrl(existing), transientHandle: null, restoreCwd: null };
+    }
+    deps.clearCanonicalDaemonInfo();
+  }
+
+  // Test / short-lived-CLI escape: skip the transient daemon spawn when
+  // TMUX_IDE_CLI_NO_AUTOSTART is set. Callers (e.g. config-cli.test.ts)
+  // exercise the local-mutation fallback path; without this guard a
+  // single `tmux-ide config enable-team` in a fixture dir would start a
+  // full embedded daemon and never tear it down in time.
+  if (process.env.TMUX_IDE_CLI_NO_AUTOSTART) {
+    return null;
+  }
+
+  const dir = deps.cwd();
+  const previousCwd = process.cwd();
+  try {
+    process.chdir(dir);
+    const handle = await deps.startEmbeddedDaemon({
+      sessionName: undefined,
+      bindHostname: "127.0.0.1",
+      silent: true,
+    });
+    if (!(await isDaemonAlive(handle.port))) {
+      await handle.stop();
+      process.chdir(previousCwd);
+      return null;
+    }
+    return { baseUrl: handle.apiBaseUrl, transientHandle: handle, restoreCwd: previousCwd };
+  } catch {
+    process.chdir(previousCwd);
+    return null;
+  }
+}
+
+async function stopTransientDaemon(daemon: {
+  transientHandle: EmbeddedDaemonHandle | null;
+  restoreCwd: string | null;
+}): Promise<void> {
+  if (daemon.transientHandle) await daemon.transientHandle.stop().catch(() => undefined);
+  if (daemon.restoreCwd) process.chdir(daemon.restoreCwd);
+}
+
+export async function tryDispatchAction<Name extends ActionName>(
+  name: Name,
+  input: ActionInput<Name>,
+  options: { cwd?: string } = {},
+): Promise<ActionResult<Name> | null> {
+  const dir = options.cwd ?? deps.cwd();
+  const previousDeps = deps;
+  deps = { ...deps, cwd: () => dir };
+  const daemon = await resolveCanonicalDaemon();
+  deps = previousDeps;
+  if (!daemon) return null;
+
+  const contract = ActionContractsZ[name];
+  const parsedInput = contract.input.parse(input);
+  let response: Response;
+  try {
+    response = await deps.fetch(`${daemon.baseUrl}/api/v2/action/${encodeURIComponent(name)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(parsedInput),
+      signal: timeoutSignal(2000),
+    });
+  } catch {
+    await stopTransientDaemon(daemon);
+    return null;
+  }
+
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    await stopTransientDaemon(daemon);
+    return null;
+  }
+  await stopTransientDaemon(daemon);
+
+  const failure = FailureEnvelopeZ.safeParse(body);
+  if (failure.success) {
+    throw new CliActionInvocationError({
+      code: failure.data.error.code as ActionErrorCode,
+      message: failure.data.error.message,
+      details: failure.data.error.details,
+    });
+  }
+
+  const success = z.object({ ok: z.literal(true), result: contract.result }).safeParse(body);
+  if (!success.success) return null;
+  return success.data.result as ActionResult<Name>;
+}