@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/google/gateway.js

@@ -84,7 +84,7 @@ async function googleResponse(options, dependencies) {
         attempt -= 1;
         continue;
       }
-      await revokeGoogleAuthorization(options.directory, options.instance, options.requiredScopes);
+      await revokeGoogleAuthorization(options.directory, options.account, options.requiredScopes);
       throw new KitRefusal("google_authority_revoked");
     }
     if (response.status === 403) {
@@ -98,13 +98,10 @@ async function googleResponse(options, dependencies) {
         throw new KitRefusal("google_provider_unavailable");
       }
       if (reasons.includes("insufficientPermissions")) {
-        await revokeGoogleAuthorization(
-          options.directory,
-          options.instance,
-          options.requiredScopes,
-        );
+        await revokeGoogleAuthorization(options.directory, options.account, options.requiredScopes);
         throw new KitRefusal("google_scope_revoked");
       }
+      if (reasons.includes("accessNotConfigured")) throw new KitRefusal("api_disabled");
       throw new KitRefusal("google_provider_unavailable");
     }
     if (RETRYABLE_STATUS.has(response.status) && attempt + 1 < RETRY_LIMIT) {

package/src/google/gmail.js

@@ -4,6 +4,7 @@ import { googleJson } from "./gateway.js";
 import { GOOGLE_SCOPES } from "./oauth.js";
 
 const GMAIL_ORIGIN = "https://gmail.googleapis.com";
+const EXCLUDED_LABELS = ["SPAM", "TRASH"];
 
 function cursorOf(value) {
   if (value === null) return { mode: "messages", pageToken: null, historyId: null };
@@ -88,18 +89,36 @@ function normalizedMessage(message) {
   };
 }
 
-async function currentHistoryId(common, dependencies) {
-  const profile = await googleJson(
-    { ...common, url: `${GMAIL_ORIGIN}/gmail/v1/users/me/profile` },
-    dependencies,
-  );
+function common(options) {
+  return {
+    directory: options.directory,
+    account: options.account,
+    requiredScopes: [GOOGLE_SCOPES.gmail],
+    signal: options.signal,
+  };
+}
+
+async function profileOf(shared, dependencies) {
+  return googleJson({ ...shared, url: `${GMAIL_ORIGIN}/gmail/v1/users/me/profile` }, dependencies);
+}
+
+async function currentHistoryId(shared, dependencies) {
+  const profile = await profileOf(shared, dependencies);
   if (typeof profile.historyId !== "string" || !/^\d+$/.test(profile.historyId)) {
     throw new KitRefusal("google_provider_response_invalid", "gmail profile");
   }
   return profile.historyId;
 }
 
-function listUrl(selection, cursor, limit, backfillFloor) {
+export async function gmailEmail(options, dependencies = {}) {
+  const profile = await profileOf(common(options), dependencies);
+  if (typeof profile.emailAddress !== "string") {
+    throw new KitRefusal("google_provider_response_invalid", "gmail profile");
+  }
+  return profile.emailAddress;
+}
+
+function listUrl(cursor, limit, backfillFloor) {
   const url = new URL(
     cursor.mode === "messages"
       ? "/gmail/v1/users/me/messages"
@@ -109,7 +128,6 @@ function listUrl(selection, cursor, limit, backfillFloor) {
   url.searchParams.set("maxResults", `${limit}`);
   if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
   if (cursor.mode === "messages") {
-    for (const label of selection.labels) url.searchParams.append("labelIds", label);
     if (backfillFloor !== null && backfillFloor !== undefined) {
       url.searchParams.set("q", `after:${Math.floor(Date.parse(backfillFloor) / 1000)}`);
     }
@@ -151,22 +169,16 @@ function referencesOf(answer, mode) {
 
 export async function gmailPage(options, dependencies = {}) {
   let cursor = cursorOf(options.cursor);
-  const common = {
-    directory: options.directory,
-    instance: options.instance,
-    client: options.client,
-    requiredScopes: [GOOGLE_SCOPES.gmail],
-    signal: options.signal,
-  };
+  const shared = common(options);
   if (cursor.mode === "messages" && cursor.historyId === null) {
-    cursor = { ...cursor, historyId: await currentHistoryId(common, dependencies) };
+    cursor = { ...cursor, historyId: await currentHistoryId(shared, dependencies) };
   }
   let answer;
   try {
     answer = await googleJson(
       {
-        ...common,
-        url: listUrl(options.selection, cursor, options.limit, options.backfillFloor),
+        ...shared,
+        url: listUrl(cursor, options.limit, options.backfillFloor),
         ...(cursor.mode === "history" ? { notFoundCode: "google_history_expired" } : {}),
       },
       dependencies,
@@ -176,10 +188,10 @@ export async function gmailPage(options, dependencies = {}) {
     cursor = {
       mode: "messages",
       pageToken: null,
-      historyId: await currentHistoryId(common, dependencies),
+      historyId: await currentHistoryId(shared, dependencies),
     };
     answer = await googleJson(
-      { ...common, url: listUrl(options.selection, cursor, options.limit, options.backfillFloor) },
+      { ...shared, url: listUrl(cursor, options.limit, options.backfillFloor) },
       dependencies,
     );
   }
@@ -197,16 +209,14 @@ export async function gmailPage(options, dependencies = {}) {
     try {
       detail = await googleJson(
         {
-          ...common,
+          ...shared,
           notFoundCode: "google_gmail_item_missing",
           url: `${GMAIL_ORIGIN}/gmail/v1/users/me/messages/${encodeURIComponent(identifier)}?format=full`,
         },
         dependencies,
       );
       const normalized = normalizedMessage(detail);
-      if (options.selection.labels.every((label) => detail.labelIds.includes(label))) {
-        items.push(normalized);
-      }
+      if (!detail.labelIds.some((label) => EXCLUDED_LABELS.includes(label))) items.push(normalized);
     } catch (error) {
       if (
         error instanceof KitRefusal &&

package/src/google/oauth.js

@@ -1,8 +1,10 @@
 import { createHash, randomBytes, randomInt } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile, rm } from "node:fs/promises";
 import { KitRefusal } from "../refusal.js";
-import { writeNote } from "../state.js";
+import { notePath, writeNote } from "../state.js";
+import { exclusively } from "../tasks.js";
+
+export const GOOGLE_SOURCES = "google";
 
 export const GOOGLE_SCOPES = Object.freeze({
   gmail: "https://www.googleapis.com/auth/gmail.readonly",
@@ -12,26 +14,30 @@ export const GOOGLE_SCOPES = Object.freeze({
 
 const AUTHORIZATION_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
 const TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+const REVOCATION_ENDPOINT = "https://oauth2.googleapis.com/revoke";
 const REFRESH_MARGIN_MS = 60_000;
 const LOOPBACK_PORT_FLOOR = 49152;
 const LOOPBACK_PORT_SPAN = 16384;
 
-function credentialPath(directory, instance) {
-  return join(directory, "state", instance, "credentials", "google.json");
+function credentialPath(directory, account) {
+  return notePath(directory, GOOGLE_SOURCES, account, "credentials");
 }
 
-async function rawAuthorization(directory, instance) {
-  const path = credentialPath(directory, instance);
+async function rawAccount(directory, account) {
+  const path = credentialPath(directory, account);
   let document;
   try {
     document = JSON.parse(await readFile(path, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return null;
-    throw new KitRefusal("google_authorization_unreadable", instance);
+    throw new KitRefusal("google_authorization_unreadable", account);
   }
   if (
     typeof document !== "object" ||
     document === null ||
+    typeof document.client?.id !== "string" ||
+    typeof document.client.secret !== "string" ||
+    (document.email !== null && typeof document.email !== "string") ||
     !Array.isArray(document.grants) ||
     document.grants.some(
       (grant) =>
@@ -46,21 +52,27 @@ async function rawAuthorization(directory, instance) {
         grant.scopes.some((scope) => typeof scope !== "string"),
     )
   ) {
-    throw new KitRefusal("google_authorization_unreadable", instance);
+    throw new KitRefusal("google_authorization_unreadable", account);
   }
   return document;
 }
 
-async function writeAuthorization(directory, instance, authorization) {
-  await writeNote(credentialPath(directory, instance), authorization);
+function updateAccount(directory, account, change) {
+  return exclusively(credentialPath(directory, account), async () => {
+    const stored = await rawAccount(directory, account);
+    const changed = change(stored);
+    if (changed !== null) await writeNote(credentialPath(directory, account), changed);
+  });
 }
 
-export async function googleAuthorization(directory, instance) {
-  const authorization = await rawAuthorization(directory, instance);
-  if (authorization === null || authorization.grants.length === 0) return null;
+export async function googleAccount(directory, account) {
+  const stored = await rawAccount(directory, account);
+  if (stored === null) return null;
   return {
-    scopes: [...new Set(authorization.grants.flatMap((grant) => grant.scopes))].sort(),
-    grants: authorization.grants.map((grant) => ({
+    client: { id: stored.client.id, secret: stored.client.secret },
+    email: stored.email,
+    scopes: [...new Set(stored.grants.flatMap((grant) => grant.scopes))].sort(),
+    grants: stored.grants.map((grant) => ({
       accessToken: grant.access_token,
       refreshToken: grant.refresh_token,
       expiresAt: grant.expires_at,
@@ -69,6 +81,15 @@ export async function googleAuthorization(directory, instance) {
   };
 }
 
+export async function googleSignedIn(directory, account, service) {
+  const stored = await rawAccount(directory, account);
+  return stored?.grants.some((grant) => grant.scopes.includes(GOOGLE_SCOPES[service])) === true;
+}
+
+export function recordGoogleEmail(directory, account, email) {
+  return updateAccount(directory, account, (stored) => (stored === null ? null : { ...stored, email }));
+}
+
 function requiredScopesOf(value) {
   if (
     !Array.isArray(value) ||
@@ -80,19 +101,51 @@ function requiredScopesOf(value) {
   return value;
 }
 
-export async function revokeGoogleAuthorization(directory, instance, scopes) {
+export async function revokeGoogleAuthorization(directory, account, scopes) {
   const requiredScopes = requiredScopesOf(scopes);
-  const authorization = await rawAuthorization(directory, instance);
-  if (authorization !== null) {
-    await writeAuthorization(directory, instance, {
-      grants: authorization.grants
-        .map((grant) => ({
-          ...grant,
-          scopes: grant.scopes.filter((scope) => !requiredScopes.includes(scope)),
-        }))
-        .filter((grant) => grant.scopes.length > 0),
+  await updateAccount(directory, account, (stored) =>
+    stored === null
+      ? null
+      : {
+          ...stored,
+          grants: stored.grants
+            .map((grant) => ({
+              ...grant,
+              scopes: grant.scopes.filter((scope) => !requiredScopes.includes(scope)),
+            }))
+            .filter((grant) => grant.scopes.length > 0),
+        },
+  );
+}
+
+async function revokedAtProvider(fetcher, token) {
+  let response;
+  try {
+    response = await fetcher(REVOCATION_ENDPOINT, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ token }).toString(),
     });
+  } catch {
+    throw new KitRefusal("google_provider_unavailable");
   }
+  if (response.status !== 200 && response.status !== 400) {
+    throw new KitRefusal("google_provider_unavailable");
+  }
+}
+
+export async function forgetGoogleAccount(directory, account, kept, dependencies = {}) {
+  const stored = await rawAccount(directory, account);
+  if (stored === null) return;
+  const others = await Promise.all(kept.map((other) => rawAccount(directory, other)));
+  if (stored.email === null || !others.some((held) => held?.email === stored.email)) {
+    for (const grant of stored.grants) {
+      await revokedAtProvider(dependencies.fetch ?? fetch, grant.refresh_token);
+    }
+  }
+  await exclusively(credentialPath(directory, account), () =>
+    rm(credentialPath(directory, account), { force: true }),
+  );
 }
 
 function oauthValue() {
@@ -167,26 +220,9 @@ async function tokenRequest(fetcher, body) {
   return answer;
 }
 
-function configuredClient(client) {
-  if (
-    typeof client?.id !== "string" ||
-    client.id.length === 0 ||
-    typeof client.secret !== "string" ||
-    client.secret.length === 0
-  ) {
-    throw new KitRefusal("google_oauth_client_unconfigured");
-  }
-  return client;
-}
-
 export async function authorizeGoogle(options, dependencies = {}) {
-  const client = configuredClient(options.client);
-  const stored = await rawAuthorization(options.directory, options.instance);
+  const { client } = options;
   const scopes = [...new Set(options.scopes)];
-  const covered = stored?.grants.some((grant) =>
-    scopes.every((scope) => grant.scopes.includes(scope)),
-  );
-  if (covered === true) return { status: "skipped", requestedScopes: [] };
   const verifier = oauthValue();
   const state = oauthValue();
   const redirectUri = loopbackRedirect(dependencies.loopbackPort);
@@ -215,10 +251,11 @@ export async function authorizeGoogle(options, dependencies = {}) {
   }
   const grantedScopes = [...new Set(returnedScopes.length === 0 ? scopes : returnedScopes)].sort();
   const key = grantedScopes.join("\n");
-  const grants = (stored?.grants ?? []).filter((grant) => [...grant.scopes].sort().join("\n") !== key);
-  await writeAuthorization(options.directory, options.instance, {
+  await updateAccount(options.directory, options.account, (stored) => ({
+    client: { id: client.id, secret: client.secret },
+    email: stored?.email ?? null,
     grants: [
-      ...grants,
+      ...(stored?.grants ?? []).filter((grant) => [...grant.scopes].sort().join("\n") !== key),
       {
         access_token: token.access_token,
         refresh_token: refreshToken,
@@ -226,48 +263,51 @@ export async function authorizeGoogle(options, dependencies = {}) {
         scopes: grantedScopes,
       },
     ],
-  });
-  return { status: "ready", requestedScopes: scopes };
+  }));
 }
 
 export async function googleAccessToken(options, dependencies = {}) {
-  const stored = await rawAuthorization(options.directory, options.instance);
+  const stored = await rawAccount(options.directory, options.account);
   const requiredScopes = requiredScopesOf(options.requiredScopes);
   const grant = stored?.grants
     .filter((candidate) => requiredScopes.every((scope) => candidate.scopes.includes(scope)))
     .sort((left, right) => left.scopes.length - right.scopes.length)[0];
   if (grant === undefined) {
-    throw new KitRefusal("google_authorization_required", options.instance);
+    throw new KitRefusal("google_authorization_required", options.account);
   }
   const now = dependencies.now?.() ?? new Date();
   if (options.forceRefresh !== true && Date.parse(grant.expires_at) - now.getTime() > REFRESH_MARGIN_MS) {
     return grant.access_token;
   }
-  const client = configuredClient(options.client);
   let token;
   try {
     token = await tokenRequest(dependencies.fetch ?? fetch, {
-      client_id: client.id,
-      client_secret: client.secret,
+      client_id: stored.client.id,
+      client_secret: stored.client.secret,
       refresh_token: grant.refresh_token,
       grant_type: "refresh_token",
     });
   } catch (error) {
     if (error instanceof KitRefusal && error.code === "google_authority_revoked") {
-      await revokeGoogleAuthorization(options.directory, options.instance, grant.scopes);
+      await revokeGoogleAuthorization(options.directory, options.account, grant.scopes);
     }
     throw error;
   }
-  await writeAuthorization(options.directory, options.instance, {
-    grants: stored.grants.map((candidate) =>
-      candidate === grant
-        ? {
-            ...candidate,
-            access_token: token.access_token,
-            expires_at: new Date(now.getTime() + token.expires_in * 1000).toISOString(),
-          }
-        : candidate,
-    ),
-  });
+  await updateAccount(options.directory, options.account, (current) =>
+    current === null
+      ? null
+      : {
+          ...current,
+          grants: current.grants.map((candidate) =>
+            candidate.refresh_token === grant.refresh_token
+              ? {
+                  ...candidate,
+                  access_token: token.access_token,
+                  expires_at: new Date(now.getTime() + token.expires_in * 1000).toISOString(),
+                }
+              : candidate,
+          ),
+        },
+  );
   return token.access_token;
 }

package/src/google/source.js

@@ -1,25 +1,23 @@
-import { KitRefusal } from "../refusal.js";
-import { gmailPage } from "./gmail.js";
-import { calendarPage } from "./calendar.js";
-import { drivePage } from "./drive.js";
-import { declaredPage } from "./declared.js";
+import { calendarEmail, calendarPage } from "./calendar.js";
+import { driveEmail, drivePage } from "./drive.js";
+import { gmailEmail, gmailPage } from "./gmail.js";
+import { googleAccount, recordGoogleEmail } from "./oauth.js";
 
-export async function googlePage(options, dependencies = {}) {
-  const common = {
-    directory: options.directory,
-    instance: options.instance,
-    client: options.client,
-    selection: options.service.selection,
-    cursor: options.cursor,
-    limit: options.limit,
-    backfillFloor: options.backfillFloor,
-    signal: options.signal,
-  };
-  if (options.service.service === "gmail") return gmailPage(common, dependencies);
-  if (options.service.service === "calendar") return calendarPage(common, dependencies);
-  if (options.service.service === "drive") return drivePage(common, dependencies);
-  if (options.service.declaration !== null) {
-    return declaredPage({ ...common, service: options.service }, dependencies);
-  }
-  throw new KitRefusal("google_service_unsupported", options.service.service);
+const SERVICES = {
+  gmail: { page: gmailPage, email: gmailEmail },
+  calendar: { page: calendarPage, email: calendarEmail },
+  drive: { page: drivePage, email: driveEmail },
+};
+
+export function googlePage(options, dependencies = {}) {
+  return SERVICES[options.service].page(options, dependencies);
+}
+
+export async function recordAccountEmail(context, google) {
+  if ((await googleAccount(context.directory, google.account))?.email !== null) return;
+  const email = await SERVICES[google.service].email(
+    { directory: context.directory, account: google.account, signal: context.signal },
+    context.dependencies,
+  );
+  await recordGoogleEmail(context.directory, google.account, email);
 }

package/src/host.js

@@ -1,7 +1,7 @@
 import { readFile, statfs } from "node:fs/promises";
 import { readConfiguration } from "./configuration.js";
 import { HOST_CPU_SAMPLE_MS } from "./contract.js";
-import { openSession, reportHostCapacity } from "./house.js";
+import { maintainControl, openSession, reportHostCapacity } from "./house.js";
 import { KitRefusal } from "./refusal.js";
 
 const PROC_STAT = "/proc/stat";
@@ -116,6 +116,10 @@ export async function reportHost(options, dependencies = {}) {
       ? observed
       : { ...observed, maxima: declaredMaxima(configuration.host.maxima) };
   const session = await openSession(options, dependencies);
-  await reportHostCapacity(session, declaration);
+  await maintainControl(
+    session,
+    (signal) => reportHostCapacity(session, declaration, signal),
+    options.signal,
+  );
   return declaration;
 }

package/src/house-main.js

@@ -1,9 +1,19 @@
-import { resolve } from "node:path";
-import { BRIDGE_NONCE_ENVIRONMENT, BRIDGE_SOCKET_ENVIRONMENT } from "./contract.js";
-import { bridgeCall } from "./mcp.js";
-import { KitRefusal } from "./refusal.js";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_PUSH_HELP,
+  WORKING_COPY_PUSH_METHOD,
+} from "./contract.js";
+import { storedHouse } from "./login.js";
+import { answerText, bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+import { ownerPush } from "./working-copy.js";
 
 const HELP = ["--help", "-h"];
+const OWNER = "--owner";
+const GIT_PUSH_USAGE = `usage: house git push [commit] [${OWNER}]`;
 const usage = (verb) => `usage: house ${verb} ['<arguments as one JSON object>' | - for standard input]`;
 
 async function answered(method, params) {
@@ -49,10 +59,59 @@ function located(verb, args) {
   return args;
 }
 
+function printed(result) {
+  const text = answerText(result);
+  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+}
+
+async function ownerPushed(request) {
+  const directory = process.env.HOUSE_KIT_HOME ?? join(homedir(), ".house-kit");
+  const cancellation = new AbortController();
+  const cancel = () => cancellation.abort();
+  process.once("SIGINT", cancel);
+  process.once("SIGTERM", cancel);
+  try {
+    const pushed = await ownerPush(
+      { house: await storedHouse(directory), directory, signal: cancellation.signal },
+      request,
+    );
+    return pushed.refused ? { err: pushed.text, status: 1 } : { out: pushed.text };
+  } catch (refusal) {
+    return { err: formatCommandError(refusal), status: 1 };
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    process.removeListener("SIGTERM", cancel);
+  }
+}
+
+async function gitPush([action, ...rest]) {
+  if (action !== "push") throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  if (rest.some((argument) => HELP.includes(argument))) return { out: `${GIT_PUSH_USAGE}\n\n${WORKING_COPY_PUSH_HELP}` };
+  const owner = rest.includes(OWNER);
+  const named = rest.filter((argument) => argument !== OWNER);
+  if (named.length > 1 || named.some((argument) => argument.startsWith("-"))) {
+    throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  }
+  const request = { cwd: process.cwd(), commit: named[0] ?? "HEAD" };
+  if (process.env[BRIDGE_SOCKET_ENVIRONMENT] === undefined) {
+    if (!owner) throw new KitRefusal("kit_bridge_unavailable");
+    return ownerPushed(request);
+  }
+  if (owner) throw new KitRefusal("kit_house_arguments_invalid", `${OWNER} is only for use outside an Agent Session`);
+  return printed(await answered(WORKING_COPY_PUSH_METHOD, request));
+}
+
 async function house([verb, argument, ...rest]) {
+  if (verb === "git") return gitPush([argument, ...rest].filter((part) => part !== undefined));
   if (verb === undefined || HELP.includes(verb)) {
     const tools = await listed();
-    return { out: [usage("<verb>"), ...tools.map((tool) => `${tool.name}\n${tool.description}`)].join("\n\n") };
+    return {
+      out: [
+        usage("<verb>"),
+        ...tools.map((tool) => `${tool.name}\n${tool.description}`),
+        `git push [commit]\n${WORKING_COPY_PUSH_HELP}`,
+      ].join("\n\n"),
+    };
   }
   if (HELP.includes(argument)) {
     const tool = (await listed()).find((one) => one.name === verb);
@@ -61,9 +120,7 @@ async function house([verb, argument, ...rest]) {
   }
   if (rest.length > 0) throw new KitRefusal("kit_house_arguments_invalid", usage(verb));
   const args = located(verb, await argumentsOf(verb, argument));
-  const result = await answered("tools/call", { name: verb, arguments: args });
-  const text = (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+  return printed(await answered("tools/call", { name: verb, arguments: args }));
 }
 
 house(process.argv.slice(2)).then(