@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/github/executors.js

@@ -1,4 +1,5 @@
-import { combineProviderActionHandlers, defineProviderExecutors, defineProviderProxy, requireBearerCredential, } from "../provider-runtime.js";
+import { combineProviderActionHandlers, defineProviderExecutors, defineProviderProxy, ProviderRequestError, requireBearerCredential, } from "../provider-runtime.js";
+import { createGitHubInstallationTokenResolver, fetchGitHubAppInstallation, mintGitHubInstallationToken, readGitHubAppInstallationCredential, } from "./app-installation.js";
 import { activityActionHandlers } from "./runtime-activity.js";
 import { issueActionHandlers } from "./runtime-issue.js";
 import { pullRequestActionHandlers } from "./runtime-pull-request.js";
@@ -9,29 +10,68 @@ import { githubApiBaseUrl, githubApiVersion, githubDefaultAcceptHeader, githubRe
 import { githubRepoEvent } from "./trigger-on-repo-event.js";
 import { githubPullRequestListener } from "./trigger-watch-pull-request.js";
 const service = "github";
-export const executors = defineProviderExecutors({
-    service,
-    handlers: combineProviderActionHandlers(service, activityActionHandlers, repositoryActionHandlers, issueActionHandlers, pullRequestActionHandlers, releaseActionHandlers, searchActionHandlers),
-    async createContext(context, fetcher) {
-        const credential = await requireBearerCredential(context, service);
-        return {
-            accessToken: credential.accessToken,
-            fetcher,
-            transitFiles: context.transitFiles,
-            signal: context.signal,
-        };
-    },
-});
+const { get_current_user, ...installationHandlers } = combineProviderActionHandlers(service, activityActionHandlers, repositoryActionHandlers, issueActionHandlers, pullRequestActionHandlers, releaseActionHandlers, searchActionHandlers);
+export const executors = {
+    ...defineProviderExecutors({
+        service,
+        handlers: installationHandlers,
+        async createContext(context, fetcher) {
+            const credential = await context.getCredential(service);
+            if (credential?.authType === "custom_credential") {
+                return {
+                    accessToken: await createGitHubInstallationTokenResolver(credential.values, fetcher)(context.signal),
+                    fetcher,
+                    transitFiles: context.transitFiles,
+                    signal: context.signal,
+                    installation: true,
+                };
+            }
+            const bearer = await requireBearerCredential(context, service);
+            return {
+                accessToken: bearer.accessToken,
+                fetcher,
+                transitFiles: context.transitFiles,
+                signal: context.signal,
+            };
+        },
+    }),
+    ...defineProviderExecutors({
+        service,
+        handlers: { get_current_user },
+        async createContext(context, fetcher) {
+            const credential = await context.getCredential(service);
+            if (credential?.authType === "custom_credential") {
+                throw new ProviderRequestError(400, "get_current_user requires a personal access token or OAuth user credential. This connection uses a GitHub App installation.");
+            }
+            const bearer = await requireBearerCredential(context, service);
+            return { accessToken: bearer.accessToken, fetcher, signal: context.signal };
+        },
+    }),
+};
 export const proxy = defineProviderProxy({
     service,
     baseUrl: githubApiBaseUrl,
-    auth: { type: "bearer" },
+    // Resolved rather than `bearer`, because an installation credential has no
+    // stored token: it is minted from the App key at request time.
+    auth: {
+        type: "bearer_resolver",
+        async resolve({ context, fetcher }) {
+            return { accessToken: await resolveGitHubAccessToken(context, fetcher) };
+        },
+    },
     skipDnsValidation: true,
     customizeRequest({ headers }) {
         headers.set("accept", githubDefaultAcceptHeader);
         headers.set("x-github-api-version", githubApiVersion);
     },
 });
+async function resolveGitHubAccessToken(context, fetcher) {
+    const credential = await context.getCredential(service);
+    if (credential?.authType === "custom_credential") {
+        return createGitHubInstallationTokenResolver(credential.values, fetcher)(context.signal);
+    }
+    return (await requireBearerCredential(context, service)).accessToken;
+}
 export const credentialValidators = {
     async apiKey(input, { fetcher }) {
         return validateGitHubToken(input.apiKey, fetcher);
@@ -39,6 +79,9 @@ export const credentialValidators = {
     async oauth2(input, { fetcher }) {
         return validateGitHubToken(input.accessToken, fetcher);
     },
+    async customCredential(input, { fetcher, signal }) {
+        return validateGitHubAppInstallation(input.values, fetcher, signal);
+    },
 };
 async function validateGitHubToken(accessToken, fetcher) {
     const user = await githubRequestJson({
@@ -59,6 +102,41 @@ async function validateGitHubToken(accessToken, fetcher) {
         },
     };
 }
+/**
+ * Prove the three inputs agree with each other and with GitHub: the key signs
+ * for this App (the installation lookup accepts the JWT), the installation
+ * belongs to it, and a token can actually be minted. The profile is the
+ * installation's account, identifying where the App is installed.
+ */
+async function validateGitHubAppInstallation(values, fetcher, signal) {
+    const credential = readGitHubAppInstallationCredential(values);
+    const installation = await fetchGitHubAppInstallation(credential, fetcher, signal);
+    const minted = await mintGitHubInstallationToken(credential, fetcher, signal);
+    const account = installation.account ?? {};
+    const login = typeof account.login === "string" ? account.login : undefined;
+    const accountId = account.id === undefined ? undefined : String(account.id);
+    const accountType = typeof account.type === "string" ? account.type : undefined;
+    if (!login && !accountId) {
+        throw new ProviderRequestError(500, "GitHub described the installation without an account", 502);
+    }
+    return {
+        profile: {
+            accountId: login ?? accountId ?? `github:installation:${credential.installationId}`,
+            displayName: `GitHub App installation on ${login ?? accountId}`,
+            // Installation permissions are the closest thing to scopes an App has;
+            // they are reported as `<permission>:<level>` so a consumer can see what
+            // the credential may read without knowing GitHub's OAuth scope names.
+            grantedScopes: Object.entries(minted.permissions).map(([permission, level]) => `${permission}:${level}`),
+        },
+        metadata: {
+            appId: credential.appId,
+            installationId: credential.installationId,
+            accountType: accountType ?? null,
+            repositorySelection: minted.repositorySelection ?? installation.repository_selection ?? null,
+            permissions: minted.permissions,
+        },
+    };
+}
 export const triggers = [
     githubRepoEvent,
     githubPullRequestListener,

package/src/providers/github/runtime-repository.js

@@ -9,7 +9,10 @@ export const repositoryActionHandlers = {
             fetcher,
         });
     },
-    list_my_repositories(input, { accessToken, fetcher }) {
+    list_my_repositories(input, { accessToken, fetcher, installation }) {
+        if (installation) {
+            return listInstallationRepositories(input, accessToken, fetcher);
+        }
         return listMyRepositories(input, accessToken, fetcher);
     },
     create_repository(input, { accessToken, fetcher }) {
@@ -295,6 +298,23 @@ async function listMyRepositories(input, accessToken, fetcher) {
     });
     return { repositories };
 }
+async function listInstallationRepositories(input, accessToken, fetcher) {
+    for (const field of ["visibility", "sort", "direction"]) {
+        if (input[field] !== undefined) {
+            throw new ProviderRequestError(400, `${field} is not supported with a GitHub App installation credential. Omit it to list the installation's repositories.`);
+        }
+    }
+    const page = await githubRequestJson({
+        path: "/installation/repositories",
+        query: compactObject({
+            per_page: optionalInteger(input.perPage),
+            page: optionalInteger(input.page),
+        }),
+        accessToken,
+        fetcher,
+    });
+    return { repositories: page.repositories ?? [] };
+}
 async function deleteRepository(input, accessToken, fetcher) {
     await githubRequestNoContent({
         method: "DELETE",

package/src/providers/github/runtime-shared.d.ts

@@ -11,9 +11,11 @@ export type GitHubActionContext = {
     fetcher: typeof fetch;
     transitFiles?: TransitFileWriter;
     signal?: AbortSignal;
+    installation?: boolean;
 };
 export type GitHubActionHandler = (input: Record<string, unknown>, context: GitHubActionContext) => Promise<unknown>;
 interface GitHubJsonRequest {
+    signal?: AbortSignal;
     method?: string;
     path: string;
     query?: Record<string, string | number | boolean | undefined>;

package/src/providers/github/runtime-shared.js

@@ -9,6 +9,7 @@ export async function githubRequestJson(input) {
     const url = buildGitHubUrl(input.path, input.query);
     const response = await input.fetcher(url, {
         method: input.method ?? "GET",
+        signal: input.signal,
         headers: githubHeaders(input.accessToken, input.body !== undefined),
         body: input.body === undefined ? undefined : JSON.stringify(input.body),
     });

package/src/providers/gmail/message.d.ts

@@ -2,7 +2,7 @@ export interface GmailMessageHeader {
     name: string;
     value: string;
 }
-export interface GmailMessagePart {
+interface GmailMessagePart {
     partId?: string;
     mimeType?: string;
     filename?: string;
@@ -80,11 +80,6 @@ export interface GmailReplyHeaders {
 export declare function resolveReplyHeaders(resource: GmailMessageResource): GmailReplyHeaders;
 /** Gmail requires a reply's subject to match its target after ordinary Re: prefixes. */
 export declare function assertMatchingReplySubject(subject: string, targetSubject: string): void;
-interface GmailBodyContent {
-    body: string;
-    isHtml: boolean;
-}
-export declare function extractBodyContent(payload: GmailMessagePart | null): GmailBodyContent;
 export declare function normalizeThreadId(value: unknown): string;
 export declare function normalizeMessageId(value: unknown): string;
 interface RecipientsInput {

package/src/providers/gmail/message.js

@@ -171,7 +171,7 @@ function parseAddressList(value) {
 function firstAddress(value) {
     return parseAddressList(value)[0] ?? "";
 }
-export function extractBodyContent(payload) {
+function extractBodyContent(payload) {
     return extractPartBody(payload, true);
 }
 function extractPartBody(payload, isBodyRoot) {

package/src/providers/googledrive/runtime-request.js

@@ -1,5 +1,5 @@
 import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const defaultService = "googledrive";
 const googleDefaultRequestTimeoutMs = 30_000;
 export async function googleJsonRequest(url, input) {
@@ -29,7 +29,7 @@ export async function googleRequest(url, input) {
     const hasRequestBody = input.rawBody != null || hasJsonBody;
     const method = (input.method ?? (hasRequestBody ? "POST" : "GET")).toUpperCase();
     if ((method === "GET" || method === "HEAD") && hasRequestBody) {
-        throw new ProviderRequestError(400, `${service} ${method} request must not include a body`);
+        throw providerInputError(`${service} ${method} request must not include a body`);
     }
     const requestInit = {
         method,
@@ -51,7 +51,7 @@ export async function googleRequest(url, input) {
         if (timeout.didTimeout() && isAbortLikeError(error)) {
             const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
             const unit = timeoutSeconds === 1 ? "second" : "seconds";
-            throw new ProviderRequestError(502, `${service} request timed out after ${timeoutSeconds} ${unit}`);
+            throw providerResponseError(`${service} request timed out after ${timeoutSeconds} ${unit}`);
         }
         throw error;
     }

package/src/providers/hrmos_kintai/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const hrmosKintaiActions: ActionDefinition[];

package/src/providers/hrmos_kintai/actions.js

@@ -0,0 +1,139 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { attendanceActions } from "./attendance-actions.js";
+import { businessActions } from "./business-actions.js";
+import { exportActions } from "./export-actions.js";
+import { pagination, employeeRecord, namedRecord, segmentRecord, attendanceRecord, reportRecord, stampRecord, leaveRecord, listOutput, } from "./schemas.js";
+export const hrmosKintaiActions = [
+    ...attendanceActions,
+    ...businessActions,
+    ...exportActions,
+    defineProviderAction("hrmos_kintai", {
+        name: "list_employees",
+        operationType: "read",
+        description: "List employees in the connected HRMOS Kintai company.",
+        inputSchema: s.object("Filters for list_employees.", {
+            ...pagination,
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(employeeRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_departments",
+        operationType: "read",
+        description: "List departments in the connected company.",
+        inputSchema: s.object("Filters for list_departments.", {
+            ...pagination,
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(namedRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_employment_types",
+        operationType: "read",
+        description: "List employment types in the connected company.",
+        inputSchema: s.object("Filters for list_employment_types.", {
+            ...pagination,
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(namedRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_workplaces",
+        operationType: "read",
+        description: "List workplaces, optionally filtered by prefecture.",
+        inputSchema: s.object("Filters for list_workplaces.", {
+            ...pagination,
+            prefectureId: s.integer("Filter workplaces by prefecture ID."),
+        }, { optional: ["prefectureId", "limit", "page", "from", "to"] }),
+        outputSchema: listOutput(namedRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_work_segments",
+        operationType: "read",
+        description: "List work classifications and their configured working hours.",
+        inputSchema: s.object("Filters for list_work_segments.", {
+            ...pagination,
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(segmentRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_leave_types",
+        operationType: "read",
+        description: "List leave settings used to query employee leave balances and history.",
+        inputSchema: s.object("Filters for list_leave_types.", {
+            ...pagination,
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(namedRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_daily_attendance",
+        operationType: "read",
+        description: "List attendance records for all employees on a specified day.",
+        inputSchema: s.object("Filters for list_daily_attendance.", {
+            ...pagination,
+            day: s.string("Target date in YYYY-MM-DD format.", { format: "date" }),
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(attendanceRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_monthly_attendance",
+        operationType: "read",
+        description: "List daily attendance records for a month, respecting each employee's cutoff date. Optionally filter by employee ID.",
+        inputSchema: s.object("Filters for list_monthly_attendance.", {
+            ...pagination,
+            month: s.string("Target month in YYYY-MM format. Attendance detail respects employee cutoff dates.", {
+                pattern: "^[0-9]{4}-(0[1-9]|1[0-2])$",
+            }),
+            employeeId: s.integer("HRMOS employee ID."),
+        }, { optional: ["employeeId", "limit", "page", "from", "to"] }),
+        outputSchema: listOutput(attendanceRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_monthly_reports",
+        operationType: "read",
+        description: "List monthly attendance summaries, optionally filtered by employee numbers and month-closing statuses.",
+        inputSchema: s.object("Filters for list_monthly_reports.", {
+            ...pagination,
+            month: s.string("Target month in YYYY-MM format. Attendance detail respects employee cutoff dates.", {
+                pattern: "^[0-9]{4}-(0[1-9]|1[0-2])$",
+            }),
+            employeeNumbers: s.array("Employee numbers to include; omit to include all employees.", s.string("Employee number.", { minLength: 1 }), { minItems: 1 }),
+            statuses: s.array("Month-closing statuses: 0 not submitted, 1 ready, 2 pending, 3 approved, 99 forcibly approved.", { ...s.integer("One month-closing status."), enum: [0, 1, 2, 3, 99] }, { minItems: 1, uniqueItems: true }),
+        }, { optional: ["employeeNumbers", "statuses", "limit", "page", "from", "to"] }),
+        outputSchema: listOutput(reportRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_daily_stamp_logs",
+        operationType: "read",
+        description: "List clock-in, clock-out and break punch history for a specified day.",
+        inputSchema: s.object("Filters for list_daily_stamp_logs.", {
+            ...pagination,
+            day: s.string("Target date in YYYY-MM-DD format.", { format: "date" }),
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(stampRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_employee_stamp_logs",
+        operationType: "read",
+        description: "List an employee's punch history, optionally filtered by punch type and update time.",
+        inputSchema: s.object("Filters for list_employee_stamp_logs.", {
+            ...pagination,
+            employeeId: s.integer("HRMOS employee ID."),
+            stampType: {
+                ...s.integer("Punch type: 1 clock-in, 2 clock-out, 7 break start, 8 break end."),
+                enum: [1, 2, 7, 8],
+            },
+        }, { optional: ["stampType", "limit", "page", "from", "to"] }),
+        outputSchema: listOutput(stampRecord),
+    }),
+    defineProviderAction("hrmos_kintai", {
+        name: "list_employee_leave_history",
+        operationType: "read",
+        description: "List an employee's leave grants, usage, adjustments and remaining balances for a leave setting and year.",
+        inputSchema: s.object("Filters for list_employee_leave_history.", {
+            ...pagination,
+            leaveTypeId: s.integer("Leave setting ID returned by list_leave_types."),
+            employeeId: s.integer("HRMOS employee ID."),
+            year: s.integer("Target leave year."),
+        }, { optional: ["limit", "page", "from", "to"] }),
+        outputSchema: listOutput(leaveRecord),
+    }),
+];

package/src/providers/hrmos_kintai/attendance-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const attendanceActions: ActionDefinition[];