@zgeoff/atc 2.8.2 → 2.9.0

package/src/parse-port.ts

@@ -0,0 +1,18 @@
+export type ParsedPort =
+  | { readonly ok: true; readonly port: number }
+  | { readonly ok: false; readonly message: string };
+
+/**
+ * Parses a `--port` value: plain decimal digits naming a port from 1 to
+ * 65535. Signs, decimals, hex, exponents, and surrounding whitespace are all
+ * refused rather than coerced.
+ */
+export function parsePort(raw: string): ParsedPort {
+  const port = /^\d{1,5}$/.test(raw) ? Number(raw) : Number.NaN;
+
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    return { ok: false, message: `--port takes a port from 1 to 65535, not '${raw}'` };
+  }
+
+  return { ok: true, port };
+}

package/src/shared/collect-mcp-http-config.ts

@@ -0,0 +1,46 @@
+import { isRecord } from './report';
+
+/**
+ * The settings `atc mcp --http` reads from config.json's `mcpHTTP` section.
+ */
+export interface MCPHTTPConfig {
+  // The origin clients reach the server at, such as `https://mcp.example.com`.
+  readonly publicURL: string | null;
+
+  // The address the server binds.
+  readonly host: string;
+  readonly port: number;
+
+  // Further Host header values to accept, for a proxy that rewrites Host.
+  readonly allowedHosts: readonly string[];
+}
+
+/**
+ * Reads the `mcpHTTP` section. An absent or wrong-typed field falls back to
+ * its default: no public URL, host 127.0.0.1, port 8414, and no extra hosts.
+ */
+export function collectMCPHTTPConfig(raw: unknown): MCPHTTPConfig {
+  if (!isRecord(raw)) {
+    return { publicURL: null, host: '127.0.0.1', port: 8414, allowedHosts: [] };
+  }
+
+  const publicURL = raw['publicURL'];
+  const host = raw['host'];
+  const port = raw['port'];
+
+  return {
+    publicURL: typeof publicURL === 'string' && publicURL !== '' ? publicURL : null,
+    host: typeof host === 'string' && host !== '' ? host : '127.0.0.1',
+    port:
+      typeof port === 'number' && Number.isInteger(port) && port >= 1 && port <= 65_535
+        ? port
+        : 8414,
+    allowedHosts: collectStrings(raw['allowedHosts']),
+  };
+}
+
+function collectStrings(raw: unknown): readonly string[] {
+  return Array.isArray(raw)
+    ? raw.filter((item): item is string => typeof item === 'string' && item !== '')
+    : [];
+}

package/src/shared/config.ts

@@ -51,12 +51,14 @@ const DEFAULTS: Config = {
 
 const configDir = join(homedir(), '.config', 'atc');
 
+export const configFile = join(configDir, 'config.json');
 export const stateDir = join(homedir(), '.local', 'state', 'atc');
 export const socketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc.sock');
 export const daemonSocketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-daemon.sock');
 export const eventsSocketPath = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-events.sock');
 export const statusFile = join(stateDir, 'status.json');
 export const dbFile = join(stateDir, 'atc.db');
+export const mcpAuthDBFile = join(stateDir, 'mcp-auth.db');
 export const legacyFleetFile = join(stateDir, 'fleet.json');
 export const daemonPidFile = join(process.env['XDG_RUNTIME_DIR'] ?? stateDir, 'atc-daemon.pid');
 
@@ -80,7 +82,7 @@ export function loadConfig(): Config {
   mkdirSync(configDir, { recursive: true });
   mkdirSync(stateDir, { recursive: true });
 
-  const file = join(configDir, 'config.json');
+  const file = configFile;
 
   if (!existsSync(file)) {
     writeFileSync(file, `${JSON.stringify(DEFAULTS, null, 2)}\n`);

package/src/shared/grant-scope.ts

@@ -0,0 +1,8 @@
+/**
+ * The access a remote MCP client can be granted, one scope per kind of tool:
+ * reading the fleet, messaging a session, spawning or typing into one, and
+ * killing one.
+ */
+export const GRANT_SCOPES = ['read', 'message', 'spawn', 'kill'] as const;
+
+export type GrantScope = (typeof GRANT_SCOPES)[number];

package/src/shared/load-mcp-http-config.ts

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { collectMCPHTTPConfig } from './collect-mcp-http-config';
+import type { MCPHTTPConfig } from './collect-mcp-http-config';
+import { configFile } from './config';
+import { isRecord } from './report';
+
+/**
+ * Reads config.json's `mcpHTTP` section for `atc mcp --http`. Nothing else in
+ * atc reads it, and a missing or unreadable file means every default.
+ */
+export function loadMCPHTTPConfig(): MCPHTTPConfig {
+  try {
+    const raw: unknown = JSON.parse(readFileSync(configFile, 'utf8'));
+    const section = isRecord(raw) ? raw['mcpHTTP'] : undefined;
+
+    return collectMCPHTTPConfig(section);
+  } catch {
+    return collectMCPHTTPConfig(undefined);
+  }
+}

package/src/shared/normalize-client-name.ts

@@ -0,0 +1,28 @@
+/**
+ * Folds a client-supplied name to a single printable terminal line: control
+ * and format characters (escape sequences, line breaks, bidi overrides) are
+ * dropped, whitespace runs become one space, and the result is trimmed and
+ * cut to `maxLength` characters. A name with nothing left becomes the
+ * fallback. Any other client-supplied text bound for the terminal, such as a
+ * user agent, folds the same way.
+ */
+export function normalizeClientName(
+  raw: unknown,
+  fallback = 'unnamed client',
+  maxLength = 100,
+): string {
+  if (typeof raw !== 'string') {
+    return fallback;
+  }
+
+  const folded = raw
+    .replaceAll(/[\t\n\v\f\r]/g, ' ')
+    .replaceAll(/[\p{Cc}\p{Cf}]/gu, '')
+    .replaceAll(/\s+/g, ' ')
+    .trim();
+
+  // The cut counts code points, so it never splits a surrogate pair.
+  const cut = folded.replace(new RegExp(`^(?<kept>.{${maxLength}}).+$`, 'su'), '$<kept>').trim();
+
+  return cut === '' ? fallback : cut;
+}

package/src/store/state-store.ts

@@ -18,6 +18,7 @@ import type { MessageOwner } from './message-owner';
 import type { MessageRecord } from './message-record';
 import { runMigrations } from './run-migrations';
 import type { StateStoreSchema } from './run-migrations';
+import type { TrailEntry } from './trail-entry';
 
 // Spelled as the partial index's predicate so SQLite can match them.
 const TRAIL_FILTER = sql<boolean>`kind IS NOT NULL AND kind != 'heartbeat'`;
@@ -33,11 +34,18 @@ export interface StoredEvent {
 
   // The event's detail, else the hook's message.
   readonly detail: string | null;
+
+  // The message id on a message status event.
+  readonly message?: MessageID;
+
+  // The report label on a report event.
+  readonly label?: string;
 }
 
 /**
- * Daemon state in one SQLite store: the restorable fleet, the hook-event
- * trail that events.read and lastActivityAt read, the spawn-directory
+ * Daemon state in one SQLite store: the restorable fleet, the event trail
+ * (hook events, message status changes, and reports) that events.read and
+ * lastActivityAt read, the spawn-directory
  * history, and the per-session message inbox. The statusline contract
  * file (status.json) stays a plain file because reporters inside wrangled
  * sessions read it without speaking to the daemon. An existing fleet.json
@@ -213,6 +221,23 @@ export class StateStore {
       .execute();
   }
 
+  async recordTrailEntry(entry: TrailEntry): Promise<void> {
+    await this.db
+      .insertInto('events')
+      .values({
+        ts: new Date(entry.at).toISOString(),
+        atc_id: entry.atcID,
+        event: entry.kind === 'report' ? 'SessionReport' : 'SessionMessage',
+
+        // The message column holds the message id or the report label; the reads hand it back by kind.
+        message: entry.kind === 'report' ? entry.label : entry.message,
+        session_id: entry.agentSessionID,
+        kind: entry.kind,
+        detail: entry.detail,
+      })
+      .execute();
+  }
+
   async collectEventsAfter(afterID: number, limit: number): Promise<StoredEvent[]> {
     const rows = await this.db
       .selectFrom('events')
@@ -298,7 +323,6 @@ export class StateStore {
       .execute();
   }
 
-  // oxlint-disable-next-line prefer-readonly-parameter-types -- every field is readonly; the branded id has no readonly form to wrap it in
   async writeMessage(record: MessageRecord): Promise<void> {
     await this.db
       .insertInto('messages')
@@ -407,6 +431,19 @@ export class StateStore {
       .execute();
   }
 
+  // Trail entries written before the agent reported its session id carry
+  // none; this stamps them once it is known, so they follow the session
+  // across a restore.
+  async updateTrailOwner(atcID: SessionID, next: AgentSessionID): Promise<void> {
+    await this.db
+      .updateTable('events')
+      .set({ session_id: next })
+      .where('atc_id', '=', atcID)
+      .where('session_id', 'is', null)
+      .where('kind', 'in', ['message-accepted', 'message-delivered', 'message-answered', 'report'])
+      .execute();
+  }
+
   async stop(): Promise<void> {
     await this.db.destroy();
 
@@ -469,13 +506,37 @@ function buildStoredEvents(rows: readonly EventRow[]): StoredEvent[] {
       atcID: toSessionID(row.atc_id),
       agentSessionID: row.session_id === null ? null : toAgentSessionID(row.session_id),
       kind: row.kind,
-      detail: row.detail ?? row.message,
+      ...buildTrailFields(row.kind, row.detail, row.message),
     });
   }
 
   return events;
 }
 
+const MESSAGE_TRAIL_KINDS: ReadonlySet<string> = new Set([
+  'message-accepted',
+  'message-delivered',
+  'message-answered',
+]);
+
+// Message and report rows keep their message id or label where hook rows keep
+// the hook's message, so only hook rows fall back to it for a detail.
+function buildTrailFields(
+  kind: string,
+  detail: string | null,
+  message: string | null,
+): Pick<StoredEvent, 'detail' | 'message' | 'label'> {
+  if (MESSAGE_TRAIL_KINDS.has(kind)) {
+    return { detail, ...(message === null ? {} : { message: toMessageID(message) }) };
+  }
+
+  if (kind === 'report') {
+    return { detail, ...(message === null ? {} : { label: message }) };
+  }
+
+  return { detail: detail ?? message };
+}
+
 function buildOwnerFilter(
   eb: ExpressionBuilder<StateStoreSchema, 'messages'>, // oxlint-disable-line prefer-readonly-parameter-types -- a kysely expression builder bound to a live query; not meaningfully freezable
   owner: MessageOwner,

package/src/store/trail-entry.ts

@@ -0,0 +1,27 @@
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { MessageID } from '../shared/message-id';
+import type { SessionID } from '../shared/session-id';
+
+interface TrailEntryBase {
+  // Epoch ms the status change or report happened.
+  readonly at: number;
+  readonly atcID: SessionID;
+  readonly agentSessionID: AgentSessionID | null;
+  readonly detail: string;
+}
+
+interface MessageTrailEntry extends TrailEntryBase {
+  readonly kind: 'message-accepted' | 'message-delivered' | 'message-answered';
+  readonly message: MessageID;
+}
+
+interface ReportTrailEntry extends TrailEntryBase {
+  readonly kind: 'report';
+  readonly label: string;
+}
+
+/**
+ * One message status change or session report as the event trail holds it,
+ * beside the hook events.
+ */
+export type TrailEntry = MessageTrailEntry | ReportTrailEntry;