@jskit-ai/connectors-catalog 0.1.1

package/docs/microsoft-oauth.md

@@ -0,0 +1,143 @@
+# Microsoft Graph registration and connection wiring
+
+Registration, tenant selection and document APIs checked: 9 September 2026. These fragments use delegated OAuth
+authorization codes with PKCE and a confidential backend registration. Provider
+HTTP is simulated in automated tests; no live Microsoft account is used.
+
+## Manual registration
+
+1. Sign in to Microsoft Entra admin center and select the directory that will
+   own the registration. Open **Entra ID → App registrations → New registration**.
+2. Name the app. For Outlook, OneDrive, Excel, OneNote, Word and PowerPoint select **Any Entra ID
+   Tenant + Personal Microsoft accounts**. For Teams and SharePoint select
+   **Multiple Entra ID tenants**. These correspond to the implemented `common`
+   and `organizations` defaults. For one directory choose **Single tenant only**
+   and copy its **Directory (tenant) ID** from the registration Overview. For a
+   personal-only registration choose **Personal accounts only** and configure
+   `consumers` (not supported by Teams/SharePoint). Select **Register** and
+   record **Application (client) ID**. [Registration instructions](https://learn.microsoft.com/en-us/entra/identity-platform/quickstart-register-app).
+3. Open **Authentication → Redirect URI configuration → Add Redirect URI**.
+   Choose **Web**, enter the exact backend callback address, then **Configure**.
+   For local development use a registered localhost callback served by the
+   operator's backend. Hosted and installed editors use the same application-owned callback;
+   neither provides a central redirect service.
+   [Redirect configuration](https://learn.microsoft.com/en-us/entra/identity-platform/how-to-add-redirect-uri).
+4. Open **API permissions → Add a permission → Microsoft Graph → Delegated
+   permissions**. Add the permission in the provider guide plus `offline_access`.
+   Consent remains subject to directory policy. The fragment does not need
+   `openid`, profile login or an application-permission service account.
+   [Delegated authorization flow](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow).
+5. Open **Certificates & secrets → Client secrets → New client secret**. Add a
+   description and expiration, then **Add**. Store **Value**, not Secret ID, in
+   private Env. Copy it before leaving the page. Microsoft recommends certificate
+   or federated credentials for production; this initial library implements
+   client-secret POST authentication only. [Credentials](https://learn.microsoft.com/en-us/entra/identity-platform/how-to-add-credentials).
+6. In the CLI JSON or shared editor form set Client ID, **Directory (tenant) ID**,
+   the secret reference and callback reference. The tenant setting accepts the
+   applicable audience keyword above or a directory GUID. It is not a URL or
+   the Application ID. Tenant domain names and sovereign clouds are not supported. Save the configuration; run the separate OAuth flow
+   below to establish a connection. After saving, use **Set credential in Env** for the client secret and
+   **Open Env** for the exact registered callback. Shared/assistant connections
+   can use **Connect account** once the application runtime is prepared. For
+   per-user mode, each user authorizes inside that application.
+
+## AI automation and application registrations
+
+Classification: **API-capable after operator authorization**. An authorized
+provisioner can create application objects through `POST /v1.0/applications`,
+setting `displayName`, `signInAudience`, `web.redirectUris` and the required
+resource permissions. Current create permissions include `AppRegistration.Create`;
+tenant policy and caller roles still apply. [Create application](https://learn.microsoft.com/en-us/graph/api/application-post-applications?view=graph-rest-1.0).
+
+It can create/rotate a secret with `POST /v1.0/applications/{object-id}/addPassword`.
+That operation requires separate authorization: delegated `Application.ReadWrite.All`
+or an appropriate application permission such as `Application.ReadWrite.OwnedBy`.
+Capture the one-time `secretText` directly into private storage. Creating an
+object does not bypass customer consent, tenant restrictions or publisher review.
+[Add password](https://learn.microsoft.com/en-us/graph/api/application-addpassword?view=graph-rest-1.0).
+
+Create the registration for the application being configured. Its backend owns
+its callback route and resolves its secret from the application environment.
+Keep development and production bindings explicit. When the callback domain
+changes, update its Web redirect URI and environment binding before reconnecting.
+See the [callback guide](../../connectors-core/docs/oauth-callbacks.md).
+
+The selected tenant and audience remain provider requirements. Editor hosting
+does not change them or grant a shared registration. App IDs do not isolate all
+user, tenant and service limits; see [Graph throttling](https://learn.microsoft.com/en-us/graph/throttling-limits).
+The automation guidance above requires operator authorization and does not
+claim a provisioning script or live registration has been tested.
+
+## CLI and application composition
+
+Use the imports and file-store composition from the
+[connection pattern](../patterns/api-key-connection/PATTERN.md), replacing the
+provider and authentication configuration. For an Outlook slot:
+
+```json
+{
+  "schemaVersion": 1,
+  "integrations": {
+    "inbox": {
+      "provider": "microsoft-outlook",
+      "accountMode": "per-user",
+      "scopes": ["Mail.Read", "offline_access"],
+      "settings": { "tenantId": "common" },
+      "authentication": { "method": "oauth2", "registrationRef": "microsoft" }
+    }
+  },
+  "registrations": {
+    "microsoft": {
+      "source": "own",
+      "clientId": "YOUR_APPLICATION_CLIENT_ID",
+      "clientSecretRef": "env:MICROSOFT_CLIENT_SECRET",
+      "callbackUrlRef": "env:MICROSOFT_CALLBACK_URL"
+    }
+  }
+}
+```
+
+Import `microsoftOutlookProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-outlook`. Pass it to
+`createConnectionService` along with parsed configuration, the environment
+resolver, a private encrypted file store and the application's authorization
+policy. The policy establishes a trusted application/subject; request body
+IDs do not establish ownership. Use a stable shared subject only after checking
+membership for a shared connection.
+
+Call `beginAuthorization({ context, integrationId, verificationInput })`. Present
+its authorization URL to that user in their browser. The existing application
+serves the configured callback and invokes
+`completeAuthorization({ context, integrationId, callbackUrl })`. It returns
+Connected only after the provider's verification read succeeds. The CLI can
+compose the same calls through an operator-owned callback server. No application
+generator or copied OAuth implementation is needed.
+
+Use `invoke` with the provider's named operation and validated inputs. Store
+returned tokens only through the private runtime store, outside application
+source. Reuse its stable encryption key across restarts. Keep bare Graph scope
+names in configuration; `offline_access` requests refresh capability and is not
+a permission to read Graph resources. These connectors do not establish an
+application login session. The selected tenant controls authorization, code
+exchange and refresh endpoints. Changing it invalidates pending attempts and
+requires reconnecting existing grants before further API access; editing the
+configuration cannot move a grant between tenants. Registrations must support
+the selected audience; schema validation cannot establish a remote client's
+registration policy.
+
+## Paging, failures and recovery
+
+List results retain `@odata.nextLink`. Supply it as `nextLink` with the original
+resource input on the next call. The fragment sends its opaque query intact
+and rejects other origins, paths, users, credentials or URL fragments. It does
+not fetch every page automatically. Endpoint path rewrites in provider paging
+URLs are currently rejected and would need separately verified support.
+[Graph paging contract](https://learn.microsoft.com/en-us/graph/paging).
+
+Cancel a pending attempt with `cancelAuthorization`; disconnect removes local
+tokens and pending attempts. It does not revoke provider-wide consent. Provider
+401/invalid grants require reconnection; 403 and 429 are controlled errors.
+Rotate expiring registration secrets in Env before removing old credentials.
+Do not log token exchange bodies. Tests cover code/state consumption, PKCE,
+permission failures, request boundaries, encrypted file restart and refresh
+rotation for all eight providers.

package/docs/microsoft-onedrive.md

@@ -0,0 +1,76 @@
+# Microsoft OneDrive
+
+Provider ID `microsoft-onedrive`; export `microsoftOneDriveProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-onedrive`.
+
+Follow all [Microsoft registration steps](microsoft-oauth.md). Choose the
+organizational + personal account audience. In **API permissions → Microsoft
+Graph → Delegated permissions**, add `Files.Read` and `offline_access`. Use an
+account with a provisioned drive; this fragment does not provision OneDrive.
+
+The verification and useful operation is `items.list`, reading
+`/v1.0/me/drive/root/children`. Inputs: optional `pageSize` (1–100, default 25;
+this fragment's bound) and `nextLink`. Initial selection includes ID, name, size,
+web URL, file/folder facets and parent reference. Results retain `value` and the
+opaque `@odata.nextLink`. Verification input is `{}`. Nested browsing uses folderId. File downloads and small uploads are described below; sharing changes remain outside this adapter.
+[Children API](https://learn.microsoft.com/en-us/graph/api/driveitem-list-children?view=graph-rest-1.0).
+
+AI provisioning is **API-capable after operator authorization** through the
+application and credential endpoints documented in the common guide. Use these
+delegated permissions and the same callback/secret fields as the CLI. The
+application owner supplies its registration and private Env bindings; tenant/user
+limits can overlap. Account consent and organizational policy remain provider
+and administrator decisions.
+
+Use the common guide's file-based library composition and ownership policy.
+Automated fixtures cover OAuth permissions, API requests, paging, cancellation,
+encrypted restart, rotation and denied access. No live account or generated app
+is used. Saving the configuration is separate from establishing a connection.
+
+## Permission choices and editor setup
+
+The form matches the captured choices: required Files.Read; initially selected
+Files.Read.All and Files.ReadWrite; optional Files.ReadWrite.All and
+Files.ReadWrite.AppFolder. offline_access requests refresh capability. For read-only use, clear optional read-all/write selections. Add the same
+selected delegated permissions to your Entra registration. The runtime retains
+explicit Files.Read for its root listing and does not infer permission equivalence.
+Selecting extra permissions does not implement new library operations.
+
+AppFolder is a distinct Microsoft permission; its API creates the folder on first
+access. This fragment never requests that endpoint during verification and does
+not implement app-folder operations. See Microsoft's
+[app-folder guide](https://learn.microsoft.com/en-us/graph/onedrive-sharepoint-appfolder).
+
+The screen supplies full Entra registration, audience/tenant, Web callback and
+secret-Value instructions. Save `env:MICROSOFT_ONEDRIVE_CLIENT_SECRET` and
+`env:MICROSOFT_ONEDRIVE_CALLBACK_URL`, then use **Set credential in Env** and
+**Open Env** for the actual values. Shared/assistant **Connect account** uses
+this application's runtime; per-user consent takes place inside the application.
+The callback and grant store remain application-owned when hosting changes.
+
+## File operations in CLI and generated apps
+
+`items.list({folderId})` navigates children; retain the returned nextLink for the
+same folder. `items.get({itemId})` returns metadata and, for downloadable files,
+`@microsoft.graph.downloadUrl`. This temporary URL itself authorizes content
+access: give it only to the authorized app user, do not log/cache it, and never
+forward the Microsoft bearer token to it. Download immediately using the browser
+or the framework's native transfer client. Treat folders as navigation, not files.
+
+`files.upload({parentId, name, bodyBase64, conflictBehavior: "fail"})` sends bytes
+up to 5 MB. Optional replace/rename must be an explicit application choice;
+Files.ReadWrite is required. CLI apps call the same connections.invoke operation.
+The editor stores only configuration and Env references. Other frameworks use
+Graph's binary PUT and their own authorization and file UI.
+
+**LIMITATIONS:** No native transfer client execution in these tests. Large files
+and resumable upload sessions are framework-owned: createUploadSession, transfer
+ordered byte ranges to its uploadUrl without the Graph bearer token, track returned
+nextExpectedRanges/expiry, and confirm the final driveItem. Keep upload URLs private.
+This adapter does not provide that resumable loop, sharing UI, app-folder automation
+or editor attachment. Example: a small report works; multi-gigabyte video needs
+native transfer wiring. No live account or generated-app proof.
+
+[Download content](https://learn.microsoft.com/en-us/graph/api/driveitem-get-content?view=graph-rest-1.0),
+[upload content](https://learn.microsoft.com/en-us/graph/api/driveitem-put-content?view=graph-rest-1.0),
+[upload sessions](https://learn.microsoft.com/en-us/graph/api/driveitem-createuploadsession?view=graph-rest-1.0).

package/docs/microsoft-onenote.md

@@ -0,0 +1,75 @@
+# Microsoft OneNote
+
+Provider ID `microsoft-onenote`; export `microsoftOneNoteProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-onenote`.
+
+Follow every [Microsoft registration step](microsoft-oauth.md), choosing the
+organizational + personal account audience. Under **API permissions → Microsoft
+Graph → Delegated permissions**, add `Notes.Read` and `offline_access`.
+Microsoft also documents `Notes.Create` as a least-privileged option for listing
+notebooks; this read fragment deliberately requests the supported `Notes.Read`
+permission for its operation. To avoid authorizing creation, clear Notes.Create and the
+optional write permissions in the editor.
+[Notebook API](https://learn.microsoft.com/en-us/graph/api/onenote-list-notebooks?view=graph-rest-1.0).
+
+`notebooks.list` verifies and lists `/v1.0/me/onenote/notebooks`. Initial input
+is `{}`; optional `nextLink` follows the provider's same-resource continuation.
+The response retains the `value` collection and paging metadata. The module
+also provides section/page traversal, content reads and text create/append below; notebook creation remains unsupported.
+
+AI provisioning is **API-capable after operator authorization** through the
+application and credential APIs in the common guide. Use this connector's
+audience and delegated permission. The AI can prepare the shared configuration
+and callback references; tenant consent remains separate. The application owns its
+registration, callback and private bindings, independently of its editor.
+Tenant and resource limits still apply.
+
+The common guide provides exact console steps, credential rotation and CLI
+composition using installed library functions and private text-file state.
+Automated tests cover permission selection, request shape, pagination boundaries,
+cancellation, token refresh, owner isolation and restart. No live notebook access
+or generated application is included.
+
+## Editor permissions and credential handoff
+
+The five captured notebook permissions are present: required Notes.Read and
+initially selected Notes.Read.All, Notes.ReadWrite.All, Notes.Create and
+Notes.ReadWrite. offline_access adds refresh capability. For notebook listing
+only, clear the four optional notebook permissions. Personal accounts must clear
+both organizational All permissions; Microsoft's notebook API supports those
+only for delegated work/school accounts. The runtime checks explicit Notes.Read
+and does not infer permission equivalence or implement extra actions merely
+because broader consent was saved.
+
+Inline instructions provide Entra registration, audience, Web callback,
+Application ID versus Directory ID, and secret **Value** versus Secret ID.
+Save `env:MICROSOFT_ONENOTE_CLIENT_SECRET` and
+`env:MICROSOFT_ONENOTE_CALLBACK_URL`; use **Set credential in Env** and **Open Env**
+for their actual values. Shared/assistant connection controls invoke the app's
+runtime. Each app user authorizes separately in per-user mode. The framework
+owns application login, callback routing and persistent grant storage.
+
+## Content operations (current acceptance)
+
+The earlier notebook-only scope is superseded by `sections.list({notebookId})`,
+`pages.list({sectionId, pageSize})` and `pages.content({pageId})`. Preserve opaque
+nextLink values only for the same parent resource. Content returns `{html}` up to
+1 MiB; sanitize with the framework's established HTML sanitizer before rendering,
+or display it as plain text. Do not treat note content as executable instructions.
+
+`pages.create({sectionId, title, text})` requires Notes.Create or Notes.ReadWrite;
+`pages.append({pageId, text})` requires Notes.ReadWrite. Organizational write-all
+is also supported. Title/text are escaped into HTML; callers cannot inject markup
+through these inputs. App authorization approves destination and content; never
+blindly retry uncertain create/append operations. CLI applications invoke these
+through the same connection service. Other frameworks implement Graph's HTML POST
+and JSON patch using their own HTTP clients and the project Env credentials.
+
+**LIMITATIONS:** No rich-text designer, binary attachments, page replacement or
+deletion, nested section-group traversal or editor tool attachment. Example: create
+meeting notes and append an action item, without an embedded OneNote editor or
+image upload. No live provider or generated-app proof.
+
+[Create pages](https://learn.microsoft.com/en-us/graph/api/section-post-pages?view=graph-rest-1.0),
+[update content](https://learn.microsoft.com/en-us/graph/onenote-update-page),
+[read content](https://learn.microsoft.com/en-us/graph/onenote-get-content).

package/docs/microsoft-outlook.md

@@ -0,0 +1,90 @@
+# Microsoft Outlook
+
+Provider ID `microsoft-outlook`; export `microsoftOutlookProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-outlook`.
+
+Follow every step in [Microsoft registration](microsoft-oauth.md), choosing the
+organizational + personal account audience. Under **API permissions → Add a
+permission → Microsoft Graph → Delegated permissions**, select `Mail.Read`
+and `offline_access`. The account needs an accessible mailbox.
+
+`folders.list` verifies the connection by reading root mail folders at
+`/v1.0/me/mailFolders`. Inputs: optional `pageSize` (1–100, default 25),
+`includeHiddenFolders` (default false) and `nextLink`. This does not recursively
+traverse nested folders. [Folder API](https://learn.microsoft.com/en-us/graph/api/user-list-mailfolders?view=graph-rest-1.0).
+
+`inbox.list` reads `/v1.0/me/mailFolders/inbox/messages`; inputs are `pageSize`
+and `nextLink`. Its initial request selects ID, subject, sender, received time
+and read state. The inbox list itself does not fetch message bodies or attachments, send email,
+or change folders. The 100-item limit is this fragment's bound.
+[Message API](https://learn.microsoft.com/en-us/graph/api/mailfolder-list-messages?view=graph-rest-1.0).
+
+Verification input is `{}`. Both operations preserve the `value` collection and
+paging link. In an application, choose a per-user connection for each person's
+inbox, or an explicitly authorized shared mailbox owner. Connecting the builder
+does not connect the application's other users.
+
+AI provisioning is **API-capable after authorization**: create the application
+and credentials with the Graph operations in the common guide, using these
+delegated permissions. The application owner supplies its registration and
+private Env bindings. Directory consent and mailbox policy remain human/provider
+decisions. The common guide contains exact console steps, portable JSON,
+library wiring and the limitations of app-ID quota separation.
+
+Automated fixtures verify this endpoint, scopes, refresh, encrypted restart,
+isolation, invalid paging destinations and controlled failures. Live mailbox use
+is excluded. Saving configuration is separate from the editor Connect action, which invokes
+the prepared application runtime’s own-registration OAuth lifecycle.
+
+## Captured permission choices and credential handoff
+
+The form includes required Mail.Read, initially selected Mail.ReadWrite, Mail.Send
+and Calendars.ReadWrite, and optional Mail.ReadBasic and Calendars.Read.
+offline_access requests refresh capability. For reading only, clear optional
+write/send/calendar permissions. Microsoft supports narrower Mail.ReadBasic for
+these list endpoints, but this form follows the captured required Mail.Read and
+the runtime explicitly checks that grant. No permission equivalence is inferred.
+Current inbox requests still select basic metadata only; broader permission does
+not itself execute the separate body, send and calendar operations described below.
+
+Inline instructions cover Entra registration, audience/tenant, Web callback,
+secret Value versus Secret ID and exact Env handoff. Save
+`env:MICROSOFT_OUTLOOK_CLIENT_SECRET` and
+`env:MICROSOFT_OUTLOOK_CALLBACK_URL`, then use **Set credential in Env** and
+**Open Env** for the values. Shared/assistant Connect uses the application's
+account; per-user mode requires each application user to connect separately.
+The app owns callbacks and grants. This fragment addresses the signed-in account's
+mailbox via /me; accessing a different Exchange shared mailbox is not implemented.
+
+## Current mailbox and calendar operations
+
+The original metadata-only scope is superseded. `messages.get({messageId})`
+requests text body content. `attachments.list({messageId})` lists attachments;
+`attachments.get({messageId, attachmentId})` reads file attachments with bounded
+Base64 content (about 5 MB). Treat returned content as untrusted; sanitize any
+HTML before rendering and never execute attachments automatically.
+
+`messages.setRead({messageId,isRead})` and `messages.move({messageId,destinationId})`
+require Mail.ReadWrite. Keep the new ID returned after moving. `messages.send`
+requires Mail.Send and `{subject,text,to:["recipient@example.com"]}` (1–20 recipients).
+It sends as the connected account and saves Sent Items. `{accepted:true}` means
+HTTP202, not successful delivery. App authorization must approve recipients and
+content; no automatic send retry after uncertainty.
+
+`calendars.list({})` and `events.list({calendarId,pageSize})` support Calendars.Read
+or Calendars.ReadWrite. `events.create({calendarId,subject,start,end})` requires
+Calendars.ReadWrite; start/end are UTC ISO strings ending in Z, with end after start.
+It creates an appointment with no attendees/invitations. The app owns time-zone
+presentation and event selection, not Vibe64.
+
+CLI uses the same connections.invoke operations; other frameworks call these
+Graph endpoints with their own HTTP client and project-owned Env/grant store.
+**LIMITATIONS:** No email-client UI, outgoing attachments, draft/reply flows,
+shared-mailbox delegation, recurrence, meeting invitations or editor attachment.
+Embedded-item/large attachments need native Graph wiring. Example: send a receipt
+and create an appointment, but no Outlook replacement. No live/generated-app proof.
+
+[Send mail](https://learn.microsoft.com/en-us/graph/api/user-sendmail?view=graph-rest-1.0),
+[move](https://learn.microsoft.com/en-us/graph/api/message-move?view=graph-rest-1.0),
+[attachments](https://learn.microsoft.com/en-us/graph/api/attachment-get?view=graph-rest-1.0),
+[events](https://learn.microsoft.com/en-us/graph/api/user-post-events?view=graph-rest-1.0).

package/docs/microsoft-powerpoint.md

@@ -0,0 +1,119 @@
+# Microsoft PowerPoint
+
+Provider ID `microsoft-powerpoint`; export `microsoftPowerPointProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-powerpoint`. This initial adapter browses
+presentation files and folders in the connected account's default drive, and reads
+file metadata. It does not read or edit presentation contents, download files,
+execute macros, create files or change sharing. A filename extension identifies
+a candidate file; it is not a check of the file's actual format.
+
+## Registration and configuration
+
+Follow the complete [Microsoft registration steps](microsoft-oauth.md).
+Use **Any Entra ID Tenant + Personal Microsoft accounts** with `common`, or the
+matching organizational, personal-only or single-directory option in that guide.
+For one directory, copy **Directory (tenant) ID** into `settings.tenantId`.
+Under **API permissions → Add a permission → Microsoft Graph → Delegated
+permissions**, select `Files.Read` and `offline_access`. Then configure the
+Web callback, create a client secret and store its Value through the referenced
+Env variable. Use an account with an existing drive; JSKIT does not provision it.
+
+```json
+{
+  "schemaVersion": 1,
+  "integrations": {
+    "files": {
+      "provider": "microsoft-powerpoint",
+      "accountMode": "per-user",
+      "scopes": [
+        "Files.Read",
+        "offline_access"
+      ],
+      "settings": {
+        "tenantId": "common"
+      },
+      "authentication": {
+        "method": "oauth2",
+        "registrationRef": "microsoft"
+      }
+    }
+  },
+  "registrations": {
+    "microsoft": {
+      "source": "own",
+      "clientId": "YOUR_APPLICATION_CLIENT_ID",
+      "clientSecretRef": "env:MICROSOFT_CLIENT_SECRET",
+      "callbackUrlRef": "env:MICROSOFT_CALLBACK_URL"
+    }
+  }
+}
+```
+
+The same values are editable in Vibe64: display name, account ownership, tenant,
+Client ID, secret/callback references and the two permission choices. Saving the
+file does not open provider consent. The [OAuth composition pattern](../patterns/oauth-connection/PATTERN.md)
+uses the library for consent, private encrypted text storage and runtime access.
+A per-user slot uses the app's authenticated subject. A shared slot uses the
+host's membership policy and stable shared subject; it is a shared account.
+
+## Runtime operations
+
+- `items.list`: optional `folderId`, `pageSize` (1–100, default 25) and `nextLink`.
+  Without `folderId`, reads `/v1.0/me/drive/root/children`; otherwise reads
+  `/v1.0/me/drive/items/{folderId}/children`. Keeps folders and files whose
+  extensions are ppt, pptx, pptm, pot, potx, potm, pps, ppsx, ppsm, case-insensitively.
+- `items.get`: required `itemId`, reading `/v1.0/me/drive/items/{itemId}`.
+  Returns a matching file's metadata. Other file types and folders produce
+  `connector_document_type_invalid`.
+
+Both operations require `Files.Read`. IDs must be opaque item IDs, not paths or
+URLs. Selected metadata includes ID, name, size, web URL, file/folder facets,
+parent reference, last modification time and ETag. The adapter does not follow
+returned URLs. [Graph children API](https://learn.microsoft.com/en-us/graph/api/driveitem-list-children?view=graph-rest-1.0),
+[Graph item API](https://learn.microsoft.com/en-us/graph/api/driveitem-get?view=graph-rest-1.0).
+
+`items.list` verifies a new connection with input `{}`. Its page size bounds the
+upstream page before local file filtering. A filtered page can be empty and
+still have `@odata.nextLink`: retain that link and pass it with the same folder
+input to continue. It is not a recursive search or an automatic full-drive scan.
+Next links cannot change Graph origin or the selected resource path.
+
+## Application registration and AI provisioning
+
+AI provisioning is **API-capable after operator authorization** using the
+application and credential endpoints in the common guide. Registration remains
+separate from account consent and tenant administrator policy.
+
+Register the callback served by this application's backend. Store its exact URL
+and client secret in application environment bindings. The same setup works with
+a CLI, installed editor or hosted editor; none supplies a shared registration.
+See the [callback guide](../../connectors-core/docs/oauth-callbacks.md) for domain
+changes and reconnect behavior. Keep the selected Microsoft tenant/audience
+consistent with the provider registration.
+
+## Evidence and limits
+
+Focused fixtures cover consent, cancellation, encrypted restart, refresh,
+reduced permissions, owner isolation, tenant changes, folder paging, empty
+filtered pages, metadata validation and controlled provider failures. Provider
+HTTP is simulated. No live account, provider registration or generated app is
+used. Provider-console administration and live account acceptance remain
+outside this fixture evidence.
+
+## Editor credential handoff
+
+The inline guide supplies Entra registration, account audience, Web callback,
+delegated permissions, secret Value and expiry steps. Save
+`env:MICROSOFT_POWERPOINT_CLIENT_SECRET` and
+`env:MICROSOFT_POWERPOINT_CALLBACK_URL`; use **Set credential in Env** and
+**Open Env** to store the values. Shared/assistant **Connect account** invokes
+the prepared application runtime. Per-user connections belong to individual
+users inside that application. No Vibe64 gateway or shared registration is used.
+
+## Existing-scope closeout — 13 September 2026
+
+Delegated project-owned OAuth browses default-drive folders and PowerPoint candidate filenames and fetches selected file metadata, with bounded paging, tenant/audience configuration and refreshed private grants.
+
+No slide/presentation content reading, creation/editing, upload/download, conversion, macros, sharing, recursive search, arbitrary drive/site selection or file format validation. Filename extension filtering is not content inspection; filtered empty pages can still have a continuation. No app-only/client-credentials or device-code grant, application login or automatic remote consent revocation. The app owns callback routes, account connection UI, authorization and file-picker/pagination behavior. Exact Lovable shared-form fields/scopes remain unverified because the saved shared-form reference is a loading placeholder. To extend: use supported native presentation tooling and file transfer, proving actual slide changes, conflict handling and format preservation; no invented Graph slide-editing endpoint. No live provider account, provider registration, paid request or generated-application execution was tested. No new editor coding-assistant tool attachment is claimed. Other frameworks use the same project configuration and their own native tools; JSKIT is optional.
+
+7 provider-specific source and 7 installed-package cases passed, plus 2 shared Microsoft tenant checks in each 16-test Word/PowerPoint run on September 13. September 12 rendered guidance/form/lifecycle evidence at 496px is retained; no new phone or browser run.

package/docs/microsoft-sharepoint.md

@@ -0,0 +1,75 @@
+# Microsoft SharePoint
+
+Provider ID `microsoft-sharepoint`; export `microsoftSharePointProvider` from
+`@jskit-ai/connectors-catalog/server/microsoft-sharepoint`.
+
+Follow all [Microsoft registration steps](microsoft-oauth.md), choosing
+**Multiple Entra ID tenants**. The module uses the `organizations` authority;
+personal Microsoft accounts are unsupported. Under **API permissions → Microsoft
+Graph → Delegated permissions**, add `Sites.Read.All`, `User.Read` and `offline_access`.
+The form requires site read and profile read; site search itself uses only
+`Sites.Read.All`. Optional site write and file read start selected. Clear them
+for a search-only application. Site manage, full control and file write are
+also available, but selecting permissions does not implement those operations.
+Site access remains limited by the signed-in user's rights and tenant policy.
+
+`sites.search` calls `/v1.0/sites?search={query}`. Pass
+`{ "search": "your site search text" }` as verification input before consent.
+The required nonempty search has a 1024-character fragment bound. Results retain
+the site `value` collection and any paging metadata; use optional `nextLink`
+for same-resource continuation with the original search input. Empty results
+are a successful authorized search, not proof of a particular site's existence.
+This fragment does not edit sites, crawl documents or implement selected-site
+application permissions. [Site search API](https://learn.microsoft.com/en-us/graph/api/site-search?view=graph-rest-1.0).
+
+AI provisioning is **API-capable after operator authorization**, using the
+application/credential APIs and these delegated permissions. The common guide
+details console navigation, application-owned client ID and private secret/callback
+references, and limitations of quota separation. Creating an app does not grant
+the user access to additional sites.
+
+Compose the same library operations and private file store from a CLI or an
+application backend, using an authenticated application/subject policy.
+Automated fixtures verify required search input, query encoding, organizational
+OAuth, permission failure, paging boundaries, cancellation, refresh and restart.
+No live tenant access or generated application is used.
+
+## Editor credential handoff
+
+The inline guide covers Entra registration, organizational audience, exact Web
+callback, delegated permissions and secret Value. Save the configuration with
+`env:MICROSOFT_SHAREPOINT_CLIENT_SECRET` and
+`env:MICROSOFT_SHAREPOINT_CALLBACK_URL`. Use **Set credential in Env** and
+**Open Env** to store their values, then enter **Site search** and connect.
+Shared/assistant connections belong to this project; per-user connections belong
+to authenticated users of the generated app. No editor-owned registration or
+gateway is involved. Rotate secrets before expiry and reconnect after consent
+changes. Local disconnect does not revoke Microsoft consent.
+
+## Current document and list operations
+
+From `sites.search`, pass the returned siteId to `libraries.list` or `lists.list`.
+`files.list({driveId,folderId?,pageSize?})` browses libraries. `files.get({driveId,itemId})`
+returns metadata and a private temporary download URL. Download through the native
+browser/client without the Microsoft Authorization header; do not log/cache the URL.
+`files.upload({driveId,parentId,name,bodyBase64,conflictBehavior?})` reuses the OneDrive
+binary-transfer implementation, capped at 5 MB, default conflict fail. Replacing
+existing files requires explicit app approval. Sites.ReadWrite.All is required.
+
+`listItems.list({siteId,listId,pageSize?})` expands fields; retain the item ETag.
+`listItems.create({siteId,listId,fields})` and
+`listItems.update({siteId,listId,itemId,fields,eTag})` use Sites.ReadWrite.All.
+Fields use internal column names, up to 100 scalar values/64 KiB. Update sends
+If-Match; on 412 reload and review the competing change. Do not automatically
+repeat uncertain writes. CLI uses the same connection service; other frameworks
+call Graph with their own HTTP clients and the same project Env ownership.
+
+**LIMITATIONS:** No site-collection creation, admin UI, complex field editors,
+sharing/permission editor or editor tool attachment. Native downloads and large
+resumable transfers are documented composition, not executed here. Example: update
+a status list/upload a report, without a SharePoint site builder. No live/generated-app proof.
+
+[Libraries](https://learn.microsoft.com/en-us/graph/api/drive-list?view=graph-rest-1.0),
+[list items](https://learn.microsoft.com/en-us/graph/api/listitem-list?view=graph-rest-1.0),
+[create](https://learn.microsoft.com/en-us/graph/api/listitem-create?view=graph-rest-1.0),
+[update](https://learn.microsoft.com/en-us/graph/api/listitem-update?view=graph-rest-1.0).