@agentshouse/kit 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/git-main.js

@@ -0,0 +1,138 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { constants as system } from "node:os";
+import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_INDEX_METHOD,
+  WORKING_COPY_RECEIVED_REF,
+} from "./contract.js";
+import { bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+
+const SHIM = realpathSync(fileURLToPath(new URL("session-bin/git", import.meta.url)));
+const VALUED = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--attr-source", "--super-prefix"]);
+const RELAYED = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+
+function nativeGit() {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (directory === "") continue;
+    const candidate = join(directory, "git");
+    try {
+      if (!statSync(candidate).isFile() || realpathSync(candidate) === SHIM) continue;
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+
+function command(args) {
+  let index = 0;
+  while (index < args.length && args[index].startsWith("-")) index += VALUED.has(args[index]) ? 2 : 1;
+  return { globals: args.slice(0, index), name: args[index], rest: args.slice(index + 1) };
+}
+
+function delegated(git, args) {
+  return new Promise((resolve) => {
+    const child = spawn(git, args, { stdio: "inherit" });
+    const relay = (signal) => child.kill(signal);
+    for (const signal of RELAYED) process.on(signal, relay);
+    const settle = (outcome) => {
+      for (const signal of RELAYED) process.off(signal, relay);
+      resolve(outcome);
+    };
+    child.once("error", (error) => {
+      process.stderr.write(`kit_git_unavailable: ${error.message}\n`);
+      settle({ status: 127, signal: null });
+    });
+    child.once("close", (status, signal) => settle({ status, signal }));
+  });
+}
+
+function captured(git, args, env = process.env) {
+  const run = spawnSync(git, args, { stdio: ["ignore", "pipe", "ignore"], maxBuffer: Infinity, env });
+  return run.status === 0 ? run.stdout.toString("utf8") : null;
+}
+
+function indexed(listing) {
+  const entries = new Map();
+  for (const record of listing.split("\0")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0) continue;
+    const [mode, object, stage] = record.slice(0, tab).split(" ");
+    entries.set(record.slice(tab + 1), stage === "0" ? `${mode} ${object}` : null);
+  }
+  return entries;
+}
+
+function renamings(output) {
+  return (output ?? "").split("\n").filter((line) => line.startsWith("Renaming ")).map((line) => line.slice(9));
+}
+
+function movedPaths(renaming, before, after) {
+  for (let at = renaming.indexOf(" to "); at >= 0; at = renaming.indexOf(" to ", at + 1)) {
+    const from = renaming.slice(0, at);
+    const to = renaming.slice(at + 4);
+    if (before.has(from) && !after.has(from) && after.get(to) === before.get(from)) return [{ from, to }];
+  }
+  return [];
+}
+
+async function recorded(cwd, change) {
+  const socket = process.env[BRIDGE_SOCKET_ENVIRONMENT];
+  const nonce = process.env[BRIDGE_NONCE_ENVIRONMENT];
+  if (socket === undefined || nonce === undefined) return;
+  try {
+    const frame = await bridgeCall({ socket, nonce }, { method: WORKING_COPY_INDEX_METHOD, params: { cwd, ...change } });
+    if (frame.error !== undefined) throw new KitRefusal(frame.error.message ?? "kit_house_refused");
+  } catch (refusal) {
+    process.stderr.write(`${formatCommandError(refusal)}: house git push will not see this index change\n`);
+  }
+}
+
+async function observed(git, { globals, name, rest }, args) {
+  const located = captured(git, [...globals, "rev-parse", "--show-toplevel", "--show-cdup", WORKING_COPY_RECEIVED_REF, "HEAD"]);
+  if (located === null) return delegated(git, args);
+  const [top, cdup, , head] = located.split("\n");
+  const listing = [...globals, "ls-files", "--stage", "-z", "--full-name", "--", cdup === "" ? "." : cdup];
+  const before = captured(git, listing);
+  const rehearsal = [...globals, "mv", "--dry-run", ...rest];
+  const planned = name === "mv" ? renamings(captured(git, rehearsal, { ...process.env, LC_ALL: "C" })) : [];
+  const outcome = await delegated(git, args);
+  const after = before === null ? null : captured(git, listing);
+  if (after === null) return outcome;
+  const [prior, next] = [indexed(before), indexed(after)];
+  const moves = outcome.status === 0 ? planned.flatMap((renaming) => movedPaths(renaming, prior, next)) : [];
+  const sources = new Set(moves.map((move) => move.from));
+  const destinations = new Set(moves.map((move) => move.to));
+  const gone = [...prior.keys()].filter((path) => !next.has(path) && !sources.has(path));
+  const arrived = [...next.keys()].filter((path) => !prior.has(path) && !destinations.has(path));
+  const heads = captured(git, [...globals, "rev-parse", "HEAD", ...(name === "rebase" ? ["ORIG_HEAD"] : [])]);
+  const [current, tip = head] = heads?.trim().split("\n") ?? [];
+  const commit = current === undefined || current === head ? [] : [tip, current];
+  if (moves.length > 0 || gone.length > 0 || arrived.length > 0 || commit.length > 0) {
+    await recorded(top, { moves, gone, arrived, commit, command: name });
+  }
+  return outcome;
+}
+
+async function run(args) {
+  const git = nativeGit();
+  if (git === null) {
+    process.stderr.write("kit_git_unavailable\n");
+    return { status: 127, signal: null };
+  }
+  return observed(git, command(args), args);
+}
+
+run(process.argv.slice(2)).then(({ status, signal }) => {
+  if (signal === null) {
+    process.exitCode = status;
+    return;
+  }
+  process.exitCode = 128 + system.signals[signal];
+  process.kill(process.pid, signal);
+});

package/src/git.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { KitRefusal } from "./refusal.js";
+
+function cancelledOr(signal, error, code) {
+  return signal?.aborted === true || error?.name === "AbortError"
+    ? new KitRefusal("kit_command_cancelled")
+    : new KitRefusal(code);
+}
+
+function stdio(capture, input) {
+  if (input !== null) return ["pipe", capture ? "pipe" : "inherit", "inherit"];
+  return capture ? ["ignore", "pipe", "inherit"] : "inherit";
+}
+
+export function runGit(cwd, args, options = {}) {
+  const { dependencies = {}, capture = false, input = null, signal, failure } = options;
+  if (signal?.aborted === true) return Promise.reject(new KitRefusal("kit_command_cancelled"));
+  const launcher = dependencies.spawn ?? spawn;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = launcher("git", args, {
+        cwd,
+        env: process.env,
+        stdio: stdio(capture, input),
+        signal,
+        killSignal: "SIGKILL",
+      });
+    } catch (error) {
+      reject(cancelledOr(signal, error, "kit_git_unavailable"));
+      return;
+    }
+    const output = [];
+    let settled = false;
+    const finish = (operation) => {
+      if (settled) return;
+      settled = true;
+      operation();
+    };
+    child.stdout?.on("data", (chunk) => output.push(Buffer.from(chunk)));
+    child.once("error", (error) =>
+      finish(() => reject(cancelledOr(signal, error, "kit_git_unavailable"))),
+    );
+    child.once("close", (status) => {
+      finish(() => {
+        if (signal?.aborted === true) {
+          reject(new KitRefusal("kit_command_cancelled"));
+          return;
+        }
+        if (status !== 0) {
+          reject(new KitRefusal(failure));
+          return;
+        }
+        resolve(Buffer.concat(output));
+      });
+    });
+    if (input !== null) {
+      child.stdin.on("error", () => undefined);
+      child.stdin.end(input);
+    }
+  });
+}

package/src/google/calendar.js

@@ -4,9 +4,10 @@ import { googleJson } from "./gateway.js";
 import { GOOGLE_SCOPES } from "./oauth.js";
 
 const CALENDAR_ORIGIN = "https://www.googleapis.com";
+const CALENDAR = "primary";
 
-function cursorOf(value, calendars) {
-  if (value === null) return { calendar: 0, pageToken: null, syncTokens: {} };
+function cursorOf(value) {
+  if (value === null) return { pageToken: null, syncToken: null };
   let cursor;
   try {
     cursor = JSON.parse(value);
@@ -16,16 +17,8 @@ function cursorOf(value, calendars) {
   if (
     typeof cursor !== "object" ||
     cursor === null ||
-    !Number.isInteger(cursor.calendar) ||
-    cursor.calendar < 0 ||
-    cursor.calendar >= calendars.length ||
     (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    typeof cursor.syncTokens !== "object" ||
-    cursor.syncTokens === null ||
-    Array.isArray(cursor.syncTokens) ||
-    Object.entries(cursor.syncTokens).some(
-      ([calendar, token]) => !calendars.includes(calendar) || typeof token !== "string",
-    )
+    (cursor.syncToken !== null && typeof cursor.syncToken !== "string")
   ) {
     throw new KitRefusal("google_checkpoint_invalid", "calendar");
   }
@@ -45,7 +38,7 @@ function authorOf(event) {
     : event.organizer.email;
 }
 
-function normalizedEvent(event, calendar) {
+function normalizedEvent(event) {
   if (
     typeof event?.id !== "string" ||
     typeof event.etag !== "string" ||
@@ -71,45 +64,53 @@ function normalizedEvent(event, calendar) {
     author: authorOf(event),
     url: event.htmlLink ?? null,
     attachments: [],
-    container: `google/calendar/${calendar}`,
+    container: `google/calendar/${CALENDAR}`,
   };
 }
 
-function pageUrl(calendar, cursor, limit, backfillFloor) {
-  const url = new URL(
-    `/calendar/v3/calendars/${encodeURIComponent(calendar)}/events`,
-    CALENDAR_ORIGIN,
-  );
+function common(options) {
+  return {
+    directory: options.directory,
+    account: options.account,
+    requiredScopes: [GOOGLE_SCOPES.calendar],
+    signal: options.signal,
+  };
+}
+
+function pageUrl(cursor, limit, backfillFloor) {
+  const url = new URL(`/calendar/v3/calendars/${CALENDAR}/events`, CALENDAR_ORIGIN);
   url.searchParams.set("maxResults", `${limit}`);
   url.searchParams.set("singleEvents", "true");
   url.searchParams.set("showDeleted", "true");
   if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
-  const syncToken = cursor.syncTokens[calendar];
-  if (syncToken !== undefined) url.searchParams.set("syncToken", syncToken);
+  if (cursor.syncToken !== null) url.searchParams.set("syncToken", cursor.syncToken);
   else if (backfillFloor !== null && backfillFloor !== undefined) {
     url.searchParams.set("timeMin", backfillFloor);
   }
   return url.toString();
 }
 
+export async function calendarEmail(options, dependencies = {}) {
+  const calendar = await googleJson(
+    { ...common(options), url: `${CALENDAR_ORIGIN}/calendar/v3/calendars/${CALENDAR}` },
+    dependencies,
+  );
+  if (typeof calendar.id !== "string") {
+    throw new KitRefusal("google_provider_response_invalid", "calendar");
+  }
+  return calendar.id;
+}
+
 export async function calendarPage(options, dependencies = {}) {
-  const calendars = options.selection.calendars;
-  let cursor = cursorOf(options.cursor, calendars);
-  const calendar = calendars[cursor.calendar];
-  const common = {
-    directory: options.directory,
-    instance: options.instance,
-    client: options.client,
-    requiredScopes: [GOOGLE_SCOPES.calendar],
-    signal: options.signal,
-  };
+  let cursor = cursorOf(options.cursor);
+  const shared = common(options);
   let answer;
   try {
     answer = await googleJson(
       {
-        ...common,
+        ...shared,
         goneCode: "google_calendar_cursor_expired",
-        url: pageUrl(calendar, cursor, options.limit, options.backfillFloor),
+        url: pageUrl(cursor, options.limit, options.backfillFloor),
       },
       dependencies,
     );
@@ -117,11 +118,9 @@ export async function calendarPage(options, dependencies = {}) {
     if (!(error instanceof KitRefusal) || error.code !== "google_calendar_cursor_expired") {
       throw error;
     }
-    const syncTokens = { ...cursor.syncTokens };
-    delete syncTokens[calendar];
-    cursor = { calendar: cursor.calendar, pageToken: null, syncTokens };
+    cursor = { pageToken: null, syncToken: null };
     answer = await googleJson(
-      { ...common, url: pageUrl(calendar, cursor, options.limit, options.backfillFloor) },
+      { ...shared, url: pageUrl(cursor, options.limit, options.backfillFloor) },
       dependencies,
     );
   }
@@ -135,23 +134,18 @@ export async function calendarPage(options, dependencies = {}) {
   }
   let next;
   if (answer.nextPageToken !== undefined) {
-    next = { calendar: cursor.calendar, pageToken: answer.nextPageToken, syncTokens: cursor.syncTokens };
+    next = { pageToken: answer.nextPageToken, syncToken: cursor.syncToken };
   } else {
     if (typeof answer.nextSyncToken !== "string") {
       throw new KitRefusal("google_provider_response_invalid", "calendar sync token");
     }
-    const syncTokens = { ...cursor.syncTokens, [calendar]: answer.nextSyncToken };
-    next = {
-      calendar: cursor.calendar + 1 === calendars.length ? 0 : cursor.calendar + 1,
-      pageToken: null,
-      syncTokens,
-    };
+    next = { pageToken: null, syncToken: answer.nextSyncToken };
   }
   const normalized = [];
   const dropped = [];
   for (const event of items) {
     try {
-      normalized.push(normalizedEvent(event, calendar));
+      normalized.push(normalizedEvent(event));
     } catch (error) {
       if (
         error instanceof KitRefusal &&
@@ -172,6 +166,6 @@ export async function calendarPage(options, dependencies = {}) {
     items: normalized,
     dropped,
     cursor: JSON.stringify(next),
-    more: answer.nextPageToken !== undefined || cursor.calendar + 1 < calendars.length,
+    more: answer.nextPageToken !== undefined,
   };
 }