@xingular/harness 0.1.6 → 1.0.0

package/dist/sdk/hub/schema.d.ts

@@ -0,0 +1,280 @@
+import { z } from 'zod';
+export declare const HUB_CATALOG_URL = "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/catalog.json";
+export declare const HUB_MAX_BYTES: number;
+export declare const HUB_PREVIEW_PAGE_BYTES: number;
+export declare const hubDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    url: z.ZodString;
+    sha256: z.ZodString;
+    bundled: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"registry">;
+    registryKind: z.ZodEnum<{
+        skills: "skills";
+        prompts: "prompts";
+        rules: "rules";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    url: z.ZodString;
+    sha256: z.ZodString;
+    bundled: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"document">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pi-package">;
+    source: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const hubEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    publisher: z.ZodString;
+    license: z.ZodString;
+    version: z.ZodString;
+    category: z.ZodString;
+    channel: z.ZodEnum<{
+        official: "official";
+        community: "community";
+    }>;
+    tags: z.ZodArray<z.ZodString>;
+    requires: z.ZodRecord<z.ZodString, z.ZodString>;
+    sourceUrl: z.ZodString;
+    delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        url: z.ZodString;
+        sha256: z.ZodString;
+        bundled: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"registry">;
+        registryKind: z.ZodEnum<{
+            skills: "skills";
+            prompts: "prompts";
+            rules: "rules";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        url: z.ZodString;
+        sha256: z.ZodString;
+        bundled: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"document">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"pi-package">;
+        source: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const hubCatalogSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        publisher: z.ZodString;
+        license: z.ZodString;
+        version: z.ZodString;
+        category: z.ZodString;
+        channel: z.ZodEnum<{
+            official: "official";
+            community: "community";
+        }>;
+        tags: z.ZodArray<z.ZodString>;
+        requires: z.ZodRecord<z.ZodString, z.ZodString>;
+        sourceUrl: z.ZodString;
+        delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"registry">;
+            registryKind: z.ZodEnum<{
+                skills: "skills";
+                prompts: "prompts";
+                rules: "rules";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"document">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pi-package">;
+            source: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const hubReceiptSchema: z.ZodObject<{
+    entry: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        publisher: z.ZodString;
+        license: z.ZodString;
+        version: z.ZodString;
+        category: z.ZodString;
+        channel: z.ZodEnum<{
+            official: "official";
+            community: "community";
+        }>;
+        tags: z.ZodArray<z.ZodString>;
+        requires: z.ZodRecord<z.ZodString, z.ZodString>;
+        sourceUrl: z.ZodString;
+        delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"registry">;
+            registryKind: z.ZodEnum<{
+                skills: "skills";
+                prompts: "prompts";
+                rules: "rules";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"document">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pi-package">;
+            source: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    installedAt: z.ZodString;
+    resourceIds: z.ZodArray<z.ZodString>;
+    document: z.ZodNullable<z.ZodString>;
+    state: z.ZodOptional<z.ZodEnum<{
+        incomplete: "incomplete";
+        installed: "installed";
+        changed: "changed";
+    }>>;
+}, z.core.$strict>;
+export declare const hubPreviewPageSchema: z.ZodObject<{
+    entry: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        publisher: z.ZodString;
+        license: z.ZodString;
+        version: z.ZodString;
+        category: z.ZodString;
+        channel: z.ZodEnum<{
+            official: "official";
+            community: "community";
+        }>;
+        tags: z.ZodArray<z.ZodString>;
+        requires: z.ZodRecord<z.ZodString, z.ZodString>;
+        sourceUrl: z.ZodString;
+        delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"registry">;
+            registryKind: z.ZodEnum<{
+                skills: "skills";
+                prompts: "prompts";
+                rules: "rules";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"document">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pi-package">;
+            source: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    content: z.ZodString;
+    offset: z.ZodNumber;
+    nextOffset: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    done: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const hubOverviewSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        publisher: z.ZodString;
+        license: z.ZodString;
+        version: z.ZodString;
+        category: z.ZodString;
+        channel: z.ZodEnum<{
+            official: "official";
+            community: "community";
+        }>;
+        tags: z.ZodArray<z.ZodString>;
+        requires: z.ZodRecord<z.ZodString, z.ZodString>;
+        sourceUrl: z.ZodString;
+        delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"registry">;
+            registryKind: z.ZodEnum<{
+                skills: "skills";
+                prompts: "prompts";
+                rules: "rules";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            url: z.ZodString;
+            sha256: z.ZodString;
+            bundled: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"document">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pi-package">;
+            source: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    installed: z.ZodArray<z.ZodObject<{
+        entry: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            publisher: z.ZodString;
+            license: z.ZodString;
+            version: z.ZodString;
+            category: z.ZodString;
+            channel: z.ZodEnum<{
+                official: "official";
+                community: "community";
+            }>;
+            tags: z.ZodArray<z.ZodString>;
+            requires: z.ZodRecord<z.ZodString, z.ZodString>;
+            sourceUrl: z.ZodString;
+            delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                url: z.ZodString;
+                sha256: z.ZodString;
+                bundled: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"registry">;
+                registryKind: z.ZodEnum<{
+                    skills: "skills";
+                    prompts: "prompts";
+                    rules: "rules";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                url: z.ZodString;
+                sha256: z.ZodString;
+                bundled: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"document">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"pi-package">;
+                source: z.ZodString;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+        installedAt: z.ZodString;
+        resourceIds: z.ZodArray<z.ZodString>;
+        document: z.ZodNullable<z.ZodString>;
+        state: z.ZodOptional<z.ZodEnum<{
+            incomplete: "incomplete";
+            installed: "installed";
+            changed: "changed";
+        }>>;
+    }, z.core.$strict>>;
+    origin: z.ZodEnum<{
+        remote: "remote";
+        bundled: "bundled";
+        cached: "cached";
+    }>;
+    refreshedAt: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    dataRoot: z.ZodNullable<z.ZodString>;
+    stateDir: z.ZodString;
+}, z.core.$strip>;
+export type HubEntry = z.infer<typeof hubEntrySchema>;
+export type HubCatalog = z.infer<typeof hubCatalogSchema>;
+export type HubReceipt = z.infer<typeof hubReceiptSchema>;
+export type HubPreviewPage = z.infer<typeof hubPreviewPageSchema>;
+export type HubOverview = z.infer<typeof hubOverviewSchema>;
+export declare function meetsMinimum(actual: string, minimum: string): boolean;

package/dist/sdk/hub/schema.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+export const HUB_CATALOG_URL = 'https://raw.githubusercontent.com/tanntnny/xingular-hub/main/catalog.json';
+export const HUB_MAX_BYTES = 16 * 1024 * 1024;
+export const HUB_PREVIEW_PAGE_BYTES = 16 * 1024;
+const httpsUrl = z.string().max(2000).url().refine((value) => {
+    const url = new URL(value);
+    return url.protocol === 'https:' && !url.username && !url.password && !url.search && !url.hash && !url.port;
+}, 'Use a public HTTPS URL without credentials, queries, or fragments.');
+const payload = {
+    url: httpsUrl,
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    bundled: z.string().max(HUB_MAX_BYTES).optional()
+};
+export const hubDeliverySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('registry'), registryKind: z.enum(['skills', 'prompts', 'rules']), ...payload }).strict(),
+    z.object({ kind: z.literal('document'), ...payload }).strict(),
+    z.object({ kind: z.literal('pi-package'), source: z.string().max(2000).refine((source) => /^npm:(?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+@\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(source)
+            || /^git:https:\/\/github\.com\/[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+(?:\.git)?@[a-f0-9]{40}$/.test(source), 'Packages must use an exact npm version or a GitHub commit.') }).strict()
+]);
+export const hubEntrySchema = z.object({
+    id: z.string().regex(/^[a-z0-9-]{1,64}\/[a-z0-9-]{1,64}$/),
+    title: z.string().min(1).max(100),
+    description: z.string().min(1).max(500),
+    publisher: z.string().min(1).max(100),
+    license: z.string().min(1).max(100),
+    version: z.string().regex(/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/),
+    category: z.string().regex(/^[a-z][a-z-]{0,40}$/),
+    channel: z.enum(['official', 'community']),
+    tags: z.array(z.string().max(60)).max(20),
+    requires: z.record(z.string(), z.string().regex(/^\d+\.\d+\.\d+$/)),
+    sourceUrl: httpsUrl,
+    delivery: hubDeliverySchema
+}).strict();
+export const hubCatalogSchema = z.object({
+    schemaVersion: z.literal(1),
+    entries: z.array(hubEntrySchema).max(2000)
+}).strict().superRefine((catalog, ctx) => {
+    const keys = new Set();
+    catalog.entries.forEach((entry, index) => {
+        const key = `${entry.id}@${entry.version}`;
+        if (keys.has(key))
+            ctx.addIssue({ code: 'custom', path: ['entries', index, 'id'], message: 'Duplicate catalog item version.' });
+        keys.add(key);
+    });
+});
+export const hubReceiptSchema = z.object({
+    entry: hubEntrySchema,
+    installedAt: z.string(),
+    resourceIds: z.array(z.string()),
+    document: z.string().nullable(),
+    state: z.enum(['installed', 'changed', 'incomplete']).optional()
+}).strict();
+export const hubPreviewPageSchema = z.object({
+    entry: hubEntrySchema,
+    content: z.string(),
+    offset: z.number().int().nonnegative(),
+    nextOffset: z.number().int().nonnegative(),
+    totalBytes: z.number().int().nonnegative(),
+    done: z.boolean()
+}).strict();
+export const hubOverviewSchema = z.object({
+    entries: z.array(hubEntrySchema),
+    installed: z.array(hubReceiptSchema),
+    origin: z.enum(['bundled', 'cached', 'remote']),
+    refreshedAt: z.string().nullable(),
+    error: z.string().nullable(),
+    dataRoot: z.string().nullable(),
+    stateDir: z.string()
+});
+export function meetsMinimum(actual, minimum) {
+    const left = actual.split(/[.-]/).slice(0, 3).map(Number);
+    const right = minimum.split('.').map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] > right[index];
+    }
+    return true;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,63 @@
+export { createHarness, Harness, type HarnessOptions, type Recovery } from "./harness.js";
+export { Doctor } from "./doctor/service.js";
+export { doctorInputSchema, doctorReportSchema, findingSchema } from "./doctor/types.js";
+export type { DoctorCheck, DoctorContext, DoctorFinding, DoctorInput, DoctorProbeContext, DoctorReport, ProviderDiagnostics, CheckResult } from "./doctor/types.js";
+export { hubCatalogSchema, hubEntrySchema, hubOverviewSchema, hubReceiptSchema, type HubCatalog, type HubEntry, type HubOverview, type HubReceipt } from "./hub/schema.js";
+export { Bus, log, type Notice } from "./core/bus.js";
+export { EMPTY_DIRECTORY, type Directory, type HarnessEnv } from "./core/env.js";
+export { HarnessError, invalid, notFound, toErrorShape, type ErrorShape } from "./core/errors.js";
+export { findBinary, searchPath } from "./core/path.js";
+export { fileSecretStore, memorySecretStore, secretKey, type SecretStore } from "./accounts/secrets.js";
+export type { Account, AccountsOverview, Pool } from "./accounts/store.js";
+export type { AccountLoginSnapshot, ModelOption } from "./accounts/accounts.js";
+export type { ChoicePatch, ModeChoice } from "./accounts/choices.js";
+export type { Capability, CapabilityCatalogue, CapabilityKind, CapabilityScope, CapabilitySet } from "./capabilities/types.js";
+export type { RunCapabilitySnapshot } from "./capabilities/runSnapshot.js";
+export type { CallerContext } from "./core/caller.js";
+export { dispatch as harnessCall } from "./tools/dispatch.js";
+export { compile, render, SECTION_ORDER, CONTEXT_MESSAGE_TYPE, CONTEXT_SNAPSHOT_KEY, type ContextPack, type HostSection, type HostToolGroup, type Launch, type Reference, type Section } from "./prompt/compile.js";
+export { runEventSchema, runRecordSchema, isActiveStatus, type ChecklistItem, type RunEvent, type RunEventType, type RunRecord } from "./sessions/contracts.js";
+export type { ApprovalFacts, ApprovalPolicy, AutomaticReason } from "./sessions/approvals.js";
+export type { ScopeDecision, ToolCall, ToolPolicy } from "./sessions/policy.js";
+export type { ActiveRun, ApprovalDecision, ApprovalInput, QuestionAnswer, QuestionInput } from "./sessions/registry.js";
+export type { RunFields, SessionRunInput } from "./sessions/sessions.js";
+export type { Effort } from "./sessions/runner.js";
+export { describeTool, HARNESS_TOOLS, DEFAULT_TOOL_NAMES, WIKI_WRITE, type HarnessCall, type HarnessToolDefinition } from "./tools/definitions.js";
+export type { ToolProvider, ToolResult, ToolSession, ToolSpec } from "./tools/types.js";
+export { SPAWN_SUBAGENT, SUBAGENT_RELATION } from "./tools/spawnSubagent.js";
+export { CHECKLIST_WRITE, checklistOf } from "./tools/checklist.js";
+export { continuationOf, type Continuation, type ContinuationBlock } from "./sessions/continuation.js";
+export { webTools, WEB_PLUGIN, WEB_SEARCH_KEY, type WebToolOptions } from "./web/tools.js";
+export { safeRequest, type WebRequest, type WebResponse } from "./web/safeRequest.js";
+export type { BrokeredTools, BrokerSession, BrokerTool } from "./mcp/service.js";
+export type { Connection, ConnectionInput, AppOAuthClients } from "./mcp/types.js";
+export { configureBuiltins, type ComponentItem, type SkillBundleInput } from "./variant/components.js";
+export { PI_SURFACE, componentOf, type ComponentGroup, type ComponentId, type ComponentInfo, type SurfaceSpec, type Variant } from "./variant/surface.js";
+export { validate as validateVariant, autotrigger, diffSummary, VariantError, type VariantCensus, type VariantDiff } from "./variant/variant.js";
+export { fingerprint, type Head, type VersionRecord, type VersionSource } from "./variant/store.js";
+export { materialise, type VariantChoice, type Materialised } from "./variant/materialise.js";
+export { seedVariant, type SeedInput } from "./variant/seed.js";
+export type { TrustedPlugin } from "./variant/trust.js";
+export { DEFAULT_REFINE_HOST, defaultDeliverable, type RefineHost, type RolloutSession, type RolloutWorkspace } from "./refine/host.js";
+export { PROBE_TRIGGER, IMPROVER_TRIGGER, type ImproverSettings } from "./refine/pi.js";
+export type { CandidateView, StartInput as RefineStartInput } from "./refine/service.js";
+export type { RefineEvent, RefineStatus, RefineSummary } from "./refine/runner.js";
+export type { Executor, Improver, RecursionMode, RefineTask, Rollout } from "./refine/types.js";
+export type { WorkPrompts } from "./refine/prompts.js";
+export type { Experience } from "./refine/library.js";
+export type { Note, NoteSummary } from "./wiki/notes.js";
+export type { TerminalAssets, TerminalLaunch, TerminalPrepareInput } from "./terminal/terminals.js";
+export { attach as attachPlugin, inventoryFor as pluginInventory, list as listPlugins, type AttachParams, type InventoryParams, type PluginScope } from "./plugins/api.js";
+export type { Attachment, AttachScope } from "./plugins/attachments.js";
+export { HARNESS_PLUGINS } from "./plugins/builtin.js";
+export { FIRST_PARTY_PLUGINS } from "./plugins/firstParty.js";
+export type { Found, Resolver } from "./plugins/discover.js";
+export type { Loading, Registered } from "./plugins/plugins.js";
+export { CONTRIBUTION_KINDS, PLUGIN_SOURCES, type ConnectorTemplate, type Contribution, type ContributionKind, type ContributionState, type Delivery, type Inventory, type InventoryItem, type Plugin, type PluginDescriptor, type PluginManage, type PluginSetting, type PluginSource } from "./plugins/types.js";
+export { methods } from "./server/methods.js";
+export { remoteDirectory, remotePolicy, remoteSecrets, remoteTools } from "./server/remote.js";
+export { PROTOCOL_VERSION, RpcPeer, stdioTransport, type Handler, type Transport } from "./server/rpc.js";
+export { attach, serve, type Served } from "./server/serve.js";
+export { DEFAULT_SUBAGENT_DEPTH, MAX_SUBAGENT_DEPTH, type SubagentOptions, type SubagentInput } from "./sessions/subagents.js";
+export { Subagents } from "./sessions/subagentService.js";
+export { WAIT_SUBAGENTS, type SubagentResult, type SubagentSelection } from "./sessions/subagents.js";

package/dist/sdk/index.js

@@ -0,0 +1,48 @@
+// @xingular/harness: a Pi agent harness built on recursive harnessing (Harness², Apache-2.0,
+// Google LLC). Each agent runs on a versioned variant of eight components (system prompt,
+// guardrails, memory, tool guidance, subagents, skills, scripts, plugins); refinement improves a
+// variant from evidence through Propose–Probe–Compose, blind selection and an experience library.
+// Around it: multi-account Pi sessions, a compiled prompt with stable-prefix delivery, project
+// notes (the Wiki), history, tools with a gate and standing approvals, and connected apps.
+//
+// An application embeds it with `createHarness` and extends it through prompt sections, tool
+// providers, a tool policy, a secret store, a directory of its own names, a description of its
+// own parts as plugins, and a refinement host. Everything else is reachable by path.
+export { createHarness, Harness } from "./harness.js";
+export { Doctor } from "./doctor/service.js";
+export { doctorInputSchema, doctorReportSchema, findingSchema } from "./doctor/types.js";
+export { hubCatalogSchema, hubEntrySchema, hubOverviewSchema, hubReceiptSchema } from "./hub/schema.js";
+export { Bus, log } from "./core/bus.js";
+export { EMPTY_DIRECTORY } from "./core/env.js";
+export { HarnessError, invalid, notFound, toErrorShape } from "./core/errors.js";
+export { findBinary, searchPath } from "./core/path.js";
+export { fileSecretStore, memorySecretStore, secretKey } from "./accounts/secrets.js";
+export { dispatch as harnessCall } from "./tools/dispatch.js";
+export { compile, render, SECTION_ORDER, CONTEXT_MESSAGE_TYPE, CONTEXT_SNAPSHOT_KEY } from "./prompt/compile.js";
+export { runEventSchema, runRecordSchema, isActiveStatus } from "./sessions/contracts.js";
+export { describeTool, HARNESS_TOOLS, DEFAULT_TOOL_NAMES, WIKI_WRITE } from "./tools/definitions.js";
+export { SPAWN_SUBAGENT, SUBAGENT_RELATION } from "./tools/spawnSubagent.js";
+export { CHECKLIST_WRITE, checklistOf } from "./tools/checklist.js";
+export { continuationOf } from "./sessions/continuation.js";
+export { webTools, WEB_PLUGIN, WEB_SEARCH_KEY } from "./web/tools.js";
+export { safeRequest } from "./web/safeRequest.js";
+export { configureBuiltins } from "./variant/components.js";
+// The variant and refinement.
+export { PI_SURFACE, componentOf } from "./variant/surface.js";
+export { validate as validateVariant, autotrigger, diffSummary, VariantError } from "./variant/variant.js";
+export { fingerprint } from "./variant/store.js";
+export { materialise } from "./variant/materialise.js";
+export { seedVariant } from "./variant/seed.js";
+export { DEFAULT_REFINE_HOST, defaultDeliverable } from "./refine/host.js";
+export { PROBE_TRIGGER, IMPROVER_TRIGGER } from "./refine/pi.js";
+export { attach as attachPlugin, inventoryFor as pluginInventory, list as listPlugins } from "./plugins/api.js";
+export { HARNESS_PLUGINS } from "./plugins/builtin.js";
+export { FIRST_PARTY_PLUGINS } from "./plugins/firstParty.js";
+export { CONTRIBUTION_KINDS, PLUGIN_SOURCES } from "./plugins/types.js";
+export { methods } from "./server/methods.js";
+export { remoteDirectory, remotePolicy, remoteSecrets, remoteTools } from "./server/remote.js";
+export { PROTOCOL_VERSION, RpcPeer, stdioTransport } from "./server/rpc.js";
+export { attach, serve } from "./server/serve.js";
+export { DEFAULT_SUBAGENT_DEPTH, MAX_SUBAGENT_DEPTH } from "./sessions/subagents.js";
+export { Subagents } from "./sessions/subagentService.js";
+export { WAIT_SUBAGENTS } from "./sessions/subagents.js";

package/dist/sdk/mcp/connections.d.ts

@@ -0,0 +1,83 @@
+import { type SecretStore } from "../accounts/secrets.js";
+import type { Bus } from "../core/bus.js";
+import type { RunEvent } from "../sessions/contracts.js";
+import { type AppOAuthClients, type Connection, type ConnectionInput, type LaunchConfig, type Scope } from "./types.js";
+/** Remote servers and sign-in pages must use TLS; plain HTTP is only for servers on this machine. */
+export declare function webUrl(text: string | null | undefined): URL | null;
+/** Whether a session with this scope may reach the connection. */
+export declare function allowed(connection: Connection, scope: Scope): boolean;
+/** Gives one agent exactly these connections, leaving every other agent's access as it was. */
+export declare function setAgentScope(all: Connection[], agentId: string, ids: readonly string[]): void;
+/**
+ * Switches one connection on or off for everyone, for one agent, or for one project, leaving
+ * every other agent's and project's access as it was.
+ */
+export declare function setScope(connection: Connection, scope: Scope, on: boolean): void;
+/** Why these connections cannot be given to a session with this scope, or nothing. */
+export declare function validateScopeIds(all: readonly Connection[], scope: Scope, ids: readonly string[]): void;
+/** Replaces the value of every `"key": "…"` in text that is not valid JSON (a truncated summary). */
+export declare function redactJsonField(text: string, key: string): string;
+/** Drops credential-like fields from a value, including from JSON carried as text. */
+export declare function scrubSensitive(value: unknown): unknown;
+/** `scrubSensitive`, and every one of `secrets` replaced wherever it appears in text. */
+export declare function scrubWith(value: unknown, secrets: readonly string[]): unknown;
+export declare function revisionOf(all: readonly Connection[]): unknown[];
+export declare class Connections {
+    private readonly secrets;
+    private readonly bus;
+    private readonly attachmentRoot;
+    private readonly appClients;
+    private readonly path;
+    /** Every secret value a connection holds, so results can be redacted without waiting on the store. */
+    private readonly known;
+    constructor(stateDir: string, secrets: SecretStore, bus: Bus, attachmentRoot?: () => string | null, appClients?: AppOAuthClients | null);
+    list(): Connection[];
+    find(id: string): Connection;
+    forScope(scope: Scope): Connection[];
+    revision(): unknown[];
+    private write;
+    private writeScope;
+    changed(): void;
+    /** Read-modify-write of one connection. */
+    update(id: string, change: (connection: Connection) => void): Connection;
+    /** Read-modify-write of every connection. */
+    updateAll(change: (all: Connection[]) => void): void;
+    /** Switches one connector in the shared attachment store, preserving all other scopes. */
+    setScope(connectionId: string, scope: Scope, on: boolean): Connection[];
+    /** Gives one agent an exact connector set without changing project or global choices. */
+    setAgentScope(agentId: string, ids: readonly string[]): Connection[];
+    /** Removes only connector choices when an agent is deleted; other capability choices are separate. */
+    removeAgentScope(agentId: string): void;
+    private secret;
+    private setSecret;
+    private deleteSecret;
+    /** Everything the secret store holds for a connection: environment and header values, and OAuth credentials. */
+    private secretValues;
+    /** Reloads the secret values used for redaction. Called at start and whenever a connection's secrets change. */
+    refreshSecrets(): Promise<void>;
+    /** A connection's result, safe to persist. */
+    scrub(value: unknown, connectionId: string): unknown;
+    /** Removes credentials from the evidence a run event carries. */
+    redactEvent(event: RunEvent): void;
+    launch(connection: Connection): Promise<LaunchConfig>;
+    private requireOauth;
+    /** The saved sign-in of a connection, with the client the user registered, or the application's own. */
+    oauthLoad(id: string): Promise<Record<string, unknown>>;
+    /** The client this application registered for a catalog entry, if it has one. */
+    private appClient;
+    /** Whether a sign-in can be started: a dynamic server registers itself, the others need a client. */
+    hasSignInClient(connection: Connection): Promise<boolean>;
+    /** The catalog entries this application can sign in for without asking for a client. */
+    availableAppClients(): string[];
+    oauthSave(id: string, state: Record<string, unknown>): Promise<void>;
+    hasOauthClient(id: string): Promise<boolean>;
+    private forgetSignIn;
+    save(input: ConnectionInput): Promise<Connection>;
+    /**
+     * Adds one tool to a connection's no-approval list. Unlike a full save this keeps the
+     * connection's pending approvals, so the request the user is answering can still be approved.
+     */
+    allowTool(connectionId: string, tool: string): Connection;
+    remove(connectionId: string): Promise<void>;
+    signOut(connectionId: string): Promise<Connection>;
+}