qlogicagent 2.13.5 → 2.13.7

package/dist/permissions.js

@@ -1 +1 @@
-export { PERMISSION_MODES, } from "./runtime/ports/permission-contracts.js";
+var e=["default","auto","full_access"];export{e as PERMISSION_MODES};

package/dist/pet-contracts.js

@@ -1 +1 @@
-export { PETDEX_ANIMATION_IDS, PETDEX_ATLAS_CONTRACT, PETDEX_SCHEMA, PETDEX_VALIDATION_SCHEMA, } from "./protocol/wire/pet-contracts.js";
+var e=["idle","running-right","running-left","waving","jumping","failed","waiting","running","review"],t="qlogic.petdex.asset.v1",i="qlogic.petdex.validation.v1",n={format:"webp",columns:8,rows:9,frameCount:72,cellWidth:192,cellHeight:208,width:1536,height:1872};export{e as PETDEX_ANIMATION_IDS,n as PETDEX_ATLAS_CONTRACT,t as PETDEX_SCHEMA,i as PETDEX_VALIDATION_SCHEMA};

package/dist/types/cli/community-skill-installer.d.ts

@@ -8,5 +8,7 @@ export interface CommunityInstalledResource {
 }
 export interface InstallCommunitySkillOptions {
     fetchFn?: typeof fetch;
+    /** Replace an existing install in place (update flow) instead of erroring. */
+    allowReplace?: boolean;
 }
 export declare function installCommunitySkillResource(install: CommunityInstallResolution, options?: InstallCommunitySkillOptions): Promise<CommunityInstalledResource>;

package/dist/types/cli/handlers/community-handler.d.ts

@@ -17,6 +17,12 @@ export declare function handleCommunitySetConsent(this: CommunityHandlerHost, ms
 export declare function handleCommunityListShared(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleCommunityMatchRegistry(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleCommunityResolveInstall(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityListResourceVersions(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityGetRatingSummary(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityRateResource(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityReportResource(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityListComments(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleCommunityPostComment(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleCommunityInstallResource(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
 /**
  * Handshake step ① — probe declared runtime dependencies (vetted catalog only).

package/dist/types/cli/runtime-dependency-catalog.d.ts

@@ -3,35 +3,45 @@
  *
  * A skill manifest may declare `runtime: ["officecli"]` — bare ids only. The
  * registry stays declarative: WHAT a skill needs lives in Hub data, but HOW to
- * probe/install it lives here, reviewed in code. The installer never executes
- * anything from registry payloads, so a compromised registry row cannot turn
- * "install skill" into arbitrary code execution; unknown ids surface as
- * "manual" in the handshake UI instead of running anything.
+ * probe/install it lives here, reviewed in code. A runtime is a single-file
+ * binary mirrored to our OSS; the installer resolves a Hub-signed download URL,
+ * verifies its sha256 BEFORE placing the file, and never executes registry
+ * payloads — so a compromised registry row cannot turn "install runtime" into
+ * arbitrary code execution. Unknown ids surface as "manual" in the handshake UI
+ * instead of running anything. CN-reliable: no dependency on foreign mirrors.
  */
 export interface RuntimeDependencySpec {
     id: string;
     /** Human-facing name shown in the handshake card. */
     label: string;
-    /** Executable probed on PATH (and `extraWindowsPaths` fallbacks). */
+    /** Executable probed on PATH (and known-location fallbacks). */
     bin: string;
     probeArgs: string[];
     /** Known install locations not yet on PATH in this process (fresh installs). */
     extraWindowsPaths?: string[];
     /**
      * quick=true → the handshake auto-installs without an extra consent step
-     * (small, single-artifact, official installer). quick=false → the client
-     * must show a consent card first (large download / system-level changes).
+     * (small, single-artifact). quick=false → the client must show a consent
+     * card first (large download / system-level changes).
      */
     quick: boolean;
     /** Honest size estimate surfaced in the consent card. */
     estSizeMB: number;
-    install: Partial<Record<"win32" | "default", {
-        command: string;
-        args: string[];
-    }>>;
+    /** Single-file binary mirrored to our OSS, resolved per-platform via the Hub. */
+    hubBinary: HubBinaryInstall;
     installTimeoutMs: number;
     docsUrl?: string;
 }
+export interface HubBinaryInstall {
+    /** Resolve id for the Hub (GET /api/v15/runtime/:id/resolve?platform=…). */
+    resourceId: string;
+    /** Absolute path the per-platform binary is written to (matches upstream layout). */
+    dest(): string;
+    /** Directory appended to the persistent user PATH so the agent shell finds `bin`. */
+    pathDir(): string;
+    /** chmod 0o755 after writing (POSIX). */
+    posixExecutable: boolean;
+}
 export declare const RUNTIME_DEPENDENCIES: Record<string, RuntimeDependencySpec>;
 export interface RuntimeDependencyStatus {
     id: string;
@@ -46,6 +56,22 @@ export interface RuntimeDependencyStatus {
     estSizeMB?: number;
     docsUrl?: string;
 }
+/** Resolved download for a hub-binary runtime (signed URL + integrity metadata). */
+export interface ResolvedRuntimeBinary {
+    version: string;
+    downloadUrl: string;
+    /** sha256 hex digest — the integrity anchor verified before placing the file. */
+    checksum: string;
+    sizeBytes: number;
+}
+export interface RuntimeInstallDeps {
+    /** Resolve a hub-binary runtime via the Hub (community client). */
+    resolveBinary(id: string, platform: string): Promise<ResolvedRuntimeBinary>;
+    /** Injectable for tests. */
+    fetchFn?: typeof fetch;
+}
+/** Map this host to the officecli asset platform key (`<os>-<arch>`). */
+export declare function runtimePlatformKey(): string;
 export declare function probeRuntimeDependency(id: string): Promise<RuntimeDependencyStatus>;
 export interface RuntimeInstallResult {
     id: string;
@@ -53,4 +79,4 @@ export interface RuntimeInstallResult {
     version?: string;
     binPath?: string;
 }
-export declare function installRuntimeDependency(id: string): Promise<RuntimeInstallResult>;
+export declare function installRuntimeDependency(id: string, deps: RuntimeInstallDeps): Promise<RuntimeInstallResult>;

package/dist/types/cli/skills-query-service.d.ts

@@ -19,6 +19,10 @@ export interface SkillListEntry {
     fallbackDescription: string;
     systemGenerated: boolean;
     version?: string;
+    /** Registry version actually installed (from the lifecycle store) — same
+     *  namespace as the catalog's latestVersion, so the UI can detect
+     *  installed < latest and offer an update. Absent for non-registry skills. */
+    registryVersion?: string;
     description?: string;
 }
 /**

package/dist/types/config/cn-mirror.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Official China-mirror env vars (WS-A1a). Single source of truth: the constant
+ * map that points dependency pulls (npm/pip/uv) at official mainland mirrors —
+ * NOT our OSS. Lives in the config layer (not infra) so it can be public API:
+ * the runtime gateway merges it into the agent env when the user's region/network
+ * switch is on (cross-cutting ③); MCP subprocesses and skill shells then inherit
+ * it via the agent-process FORWARDED_ENV_KEYS list.
+ *
+ * Honest scope: this only redirects dependency *resolution* to official mirrors
+ * (covers most). It does NOT guarantee cold/new packages (npmmirror sync lag →
+ * 404) or run-time foreign APIs — those are surfaced as reachability notices (WS-A6).
+ */
+export declare const CN_NPM_REGISTRY = "https://registry.npmmirror.com";
+export declare const CN_PYPI_INDEX = "https://pypi.tuna.tsinghua.edu.cn/simple";
+/** npmmirror's binary host — runtime interpreters (python-build-standalone, node dist). */
+export declare const CN_BINARY_HOST = "https://registry.npmmirror.com/-/binary";
+/** Mirror endpoint values (official mirrors, not our OSS). */
+export declare function buildCnMirrorEnv(): Record<string, string>;
+/**
+ * The env keys `buildCnMirrorEnv()` sets. agent-process appends these to its
+ * forwarded-env list so a mirror set on the agent propagates to MCP/skill children.
+ */
+export declare const CN_MIRROR_ENV_KEYS: string[];

package/dist/types/index.d.ts

@@ -12,4 +12,5 @@ export { StdioTransport } from "./cli/transport.js";
 export { StdioServer, type StdioServerConfig } from "./cli/stdio-server.js";
 export type { LLMTransport, LLMRequest, LLMChunk } from "./runtime/ports/index.js";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";
+export { buildCnMirrorEnv, CN_MIRROR_ENV_KEYS } from "./config/cn-mirror.js";
 export { buildSkillInstruction, } from "./orchestration/index.js";

package/dist/types/protocol/methods.d.ts

@@ -232,7 +232,15 @@ export interface SettingsListModelsResult {
         provider: string;
         model: string;
         displayName: string;
-        purposes: string[];
+        routeIntents: string[];
+        capabilityProfile?: {
+            tasks?: string[];
+            input_modalities?: string[];
+            output_modalities?: string[];
+            traits?: string[];
+            verification?: Record<string, unknown>;
+            cost?: Record<string, unknown>;
+        };
         baseUrl?: string;
         enabled: boolean;
     }>;
@@ -241,7 +249,15 @@ export interface SettingsListModelsResult {
         provider: string;
         model: string;
         displayName: string;
-        purposes: string[];
+        routeIntents: string[];
+        capabilityProfile?: {
+            tasks?: string[];
+            input_modalities?: string[];
+            output_modalities?: string[];
+            traits?: string[];
+            verification?: Record<string, unknown>;
+            cost?: Record<string, unknown>;
+        };
         baseUrl?: string;
         enabled: boolean;
     }>>;
@@ -259,7 +275,15 @@ export interface SettingsGetActiveModelResult {
         provider: string;
         model: string;
         displayName: string;
-        purposes: string[];
+        routeIntents: string[];
+        capabilityProfile?: {
+            tasks?: string[];
+            input_modalities?: string[];
+            output_modalities?: string[];
+            traits?: string[];
+            verification?: Record<string, unknown>;
+            cost?: Record<string, unknown>;
+        };
         enabled: boolean;
     } | null;
     available: boolean;

package/dist/types/runtime/community/community-consent-client.d.ts

@@ -24,12 +24,35 @@ export interface CommunityConsentClient {
     recordSignal(input: CommunityRecordSignalInput): Promise<CommunityRecordSignalResult>;
     recordTelemetry(input: CommunityRecordTelemetryInput): Promise<CommunityRecordTelemetryResult>;
     resolveInstall(resourceId: string, version?: string): Promise<CommunityInstallResolution>;
+    /** List a resource's published versions for the version/rollback menu (WS-B3). The
+     *  default client always implements it; optional so lightweight mocks may omit it. */
+    listResourceVersions?(resourceId: string): Promise<CommunityResourceVersion[]>;
+    /** Rate a resource 1–5 (WS-B4); returns the new summary. Optional for mocks. */
+    rateResource?(resourceId: string, stars: number): Promise<CommunityRatingSummary>;
+    /** Current rating average + count (WS-B4). Optional for mocks. */
+    getRatingSummary?(resourceId: string): Promise<CommunityRatingSummary>;
+    /** Report a resource for abuse (WS-B4). Optional for mocks. */
+    reportResource?(resourceId: string, reason?: string): Promise<void>;
+    /** List community comments for a resource (WS-B4). Optional for mocks. */
+    listComments?(resourceId: string): Promise<CommunityComment[]>;
+    /** Post a community comment (WS-B4); new accounts are folded by the Hub. Optional for mocks. */
+    postComment?(resourceId: string, body: string): Promise<CommunityCommentPosted>;
+    /** Resolve a vetted runtime binary (e.g. officecli) for this platform → Hub-signed download. */
+    resolveRuntime(id: string, platform: string): Promise<CommunityRuntimeResolution>;
     listSharedResources(): Promise<CommunitySharedResource[]>;
     withdrawSharedResource(resourceId: string, reason?: string): Promise<CommunitySharedResource>;
     withdrawSharedResources(reason?: string): Promise<CommunitySharedResource[]>;
     listNotices(input?: CommunityListNoticesInput): Promise<CommunityNotice[]>;
     markNoticeRead(noticeId: number): Promise<CommunityNotice>;
 }
+export interface CommunityRuntimeResolution {
+    id: string;
+    version: string;
+    downloadUrl: string;
+    /** sha256 hex digest — verified client-side before placing the binary. */
+    checksum: string;
+    sizeBytes: number;
+}
 export interface CommunitySharedResource {
     id: string;
     type: string;
@@ -96,12 +119,14 @@ export interface CommunityRecordTelemetryInput {
 export interface CommunityRecordTelemetryResult {
     accepted: true;
 }
+/** Notice event set, mirrors the Hub's opened CHECK (cross-cutting ④). */
+export type CommunityNoticeEvent = "withdrawn" | "version-available" | "deprecated" | "version-yanked" | "frozen";
 export interface CommunityNotice {
     id: number;
     resourceId: string;
     resourceType: string;
     title: string;
-    event: "withdrawn";
+    event: CommunityNoticeEvent;
     version: string | null;
     reason: string | null;
     read: boolean;
@@ -131,11 +156,43 @@ export interface CommunityInstallResolution {
     sizeBytes: number;
     downloadUrl: string;
     manifest: unknown;
+    /** Minimum client version the resource declares, when present (cross-cutting ①). */
+    minClientVersion?: string;
+    /** EdDSA signature (base64) + signing key id over the integrity metadata (WS-B1). */
+    signature?: string | null;
+    signingKeyId?: string | null;
+}
+export interface CommunityResourceVersion {
+    version: string;
+    createdAt: string;
+    sizeBytes: number;
+    yanked: boolean;
+}
+export interface CommunityRatingSummary {
+    average: number;
+    count: number;
+}
+export interface CommunityComment {
+    id: number;
+    body: string;
+    folded: boolean;
+    createdAt: string;
+}
+export interface CommunityCommentPosted {
+    id: number;
+    folded: boolean;
+    createdAt: string;
 }
 export interface CommunityConsentClientOptions {
     baseUrl: string;
     token: string;
     fetchFn?: typeof fetch;
+    /**
+     * Client version reported to the Hub via the `x-client-version` header on
+     * every registry request (version negotiation skeleton, cross-cutting ①).
+     * Omitted when unknown — the Hub records it but never rejects in Phase 1.
+     */
+    clientVersion?: string;
 }
 export declare function createCommunityConsentClient(options: CommunityConsentClientOptions): CommunityConsentClient;
 export declare function createDefaultCommunityConsentClient(configPort?: ConfigPort): CommunityConsentClient | null;

package/dist/types/runtime/community/community-telemetry-types.d.ts

@@ -1 +1 @@
-export type CommunityTelemetryEvent = "community.journey.view" | "community.share.generated" | "community.sandbox.violation" | "community.desensitization.hit";
+export type CommunityTelemetryEvent = "community.journey.view" | "community.share.generated" | "community.sandbox.violation" | "community.desensitization.hit" | "registry.install_failed";

package/dist/types/runtime/community/package-materialize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared community-package materialization (download → verify → extract).
+ *
+ * Single source of truth for turning a registry install resolution into bytes on
+ * disk: whole-package sha256 + size check, then a minimal tar.gz extractor with a
+ * path-traversal guard. Used by the skill installer and the pet asset installer so
+ * the security-sensitive verify/extract logic lives in exactly one place.
+ */
+import type { CommunityInstallResolution } from "./community-consent-client.js";
+/**
+ * Fetch the package, verifying it matches the registry's size + sha256. Delegates
+ * to the ranged downloader (WS-C4): 4MB Range chunks + .part resume for large
+ * assets, with a transparent whole-body fallback for small/non-Range packages.
+ */
+export declare function downloadAndVerifyPackage(fetchFn: typeof fetch, install: Pick<CommunityInstallResolution, "downloadUrl" | "sizeBytes" | "checksum">, label: string): Promise<Buffer>;
+/** Extract a gzip-compressed tar into targetDir; only regular files + dirs, no traversal. */
+export declare function extractTarGz(pkg: Buffer, targetDir: string, label: string): Promise<void>;
+/** Resolve a tar entry under rootDir, rejecting absolute paths and `..` traversal. */
+export declare function safeTarTarget(rootDir: string, entryName: string, label: string): string;

package/dist/types/runtime/community/ranged-download.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ranged package download with resume (WS-C4). Fetches a package in 4MB Range
+ * chunks into a `.part` file (resumable across retries/process restarts), with
+ * per-chunk retry, then verifies the assembled file's size + sha256 and returns
+ * the bytes. When the server ignores Range (responds 200 instead of 206) it
+ * falls back to verifying the whole body in memory — so small packages and
+ * non-Range servers cost no disk. Verify semantics are identical to the plain
+ * downloader, so callers are unchanged.
+ */
+export interface RangedDownloadTarget {
+    downloadUrl: string;
+    sizeBytes: number;
+    checksum: string;
+}
+export declare function rangedDownloadVerified(fetchFn: typeof fetch, target: RangedDownloadTarget, label: string): Promise<Buffer>;

package/dist/types/runtime/community/registry-signature.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Client-side registry signature verification (WS-B1, cross-cutting ⑤).
+ *
+ * `canonicalSigningPayload` MUST be byte-identical to the Hub's
+ * `core/registry/registry-signing.ts` — a hand-written fixed field order joined by
+ * newlines, never JSON. The shared golden vector in both repos' tests pins this so
+ * the two implementations can never silently diverge (a drift would make every
+ * signature fail to verify). Verification is a second anchor beside the sha256
+ * checksum in the download path; the trusted public key is built into the client.
+ */
+export interface SignablePackage {
+    id: string;
+    version: string;
+    checksum: string;
+    sizeBytes: number;
+}
+/** Byte-exact canonical payload — keep identical to the Hub. Fixed order; never reorder. */
+export declare function canonicalSigningPayload(p: SignablePackage): string;
+/**
+ * Normalize a PEM that may arrive with escaped newlines. The trusted public key is
+ * sourced from env (QLOGIC_REGISTRY_SIGNING_PUBLIC_KEY_PEM); env_file / single-line
+ * secret stores deliver `\n` as literal backslash-n, which createPublicKey rejects.
+ * No-op when the PEM already has real newlines, so it never affects valid keys.
+ */
+export declare function normalizePem(pem: string): string;
+/** Verify an Ed25519 signature (base64) over the canonical payload. False on any error. */
+export declare function verifyPackageSignature(p: SignablePackage, signatureBase64: string, publicKeyPem: string): boolean;
+/**
+ * Signature gate mode (WS-B1 gradual rollout): "warn" logs but installs; "strict"
+ * refuses an install whose signature is missing or invalid. Sourced from
+ * QLOGIC_REGISTRY_SIGNATURE_MODE; defaults to "warn" so backfill can precede strict.
+ */
+export type SignatureMode = "warn" | "strict";
+export declare function resolveSignatureMode(value: string | undefined): SignatureMode;
+export interface SignedResolution extends SignablePackage {
+    signature?: string | null;
+    signingKeyId?: string | null;
+}
+/**
+ * Dual-anchor signature gate (WS-B1) applied beside the sha256 check on install.
+ * strict: throw on a missing or invalid signature. warn (default): never throw —
+ * return the outcome so the caller can log it. A missing trusted public key (key
+ * ceremony not yet done) behaves like "unsigned" so warn-mode installs proceed.
+ */
+export declare function checkResolutionSignature(resolution: SignedResolution, mode: SignatureMode, trustedPublicKeyPem: string | undefined): {
+    verified: boolean;
+    reason?: "unsigned" | "no-trusted-key" | "invalid-signature";
+};

package/dist/types/runtime/infra/llmrouter-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { ModelEntry, ModelRegistry, ReasoningMode } from "./model-registry.js";
+import type { ModelCapabilityProfile, ModelEntry, ModelRegistry, ReasoningMode } from "./model-registry.js";
 import type { ConfigPort } from "../ports/index.js";
 export declare const LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE = "\u65E0\u6CD5\u8FDE\u63A5 llmrouter \u6A21\u578B\u76EE\u5F55";
 export declare const LLMROUTER_PROVIDER_ID = "llmrouter";
@@ -35,7 +35,7 @@ export interface LlmrouterCatalogModel {
     displayName?: string;
     name?: string;
     category?: string;
-    purposes?: string[];
+    route_intents?: string[];
     baseUrl?: string;
     base_url?: string;
     provider_transport?: string;
@@ -52,7 +52,7 @@ export interface LlmrouterCatalogModel {
     reasoningMode?: ReasoningMode;
     media_type?: string | null;
     mediaType?: string | null;
-    capabilities?: string[];
+    capability_profile?: ModelCapabilityProfile;
     pricing?: Record<string, unknown>;
 }
 export declare function getLlmrouterBaseUrl(configPort?: ConfigPort): string;

package/dist/types/runtime/infra/model-registry.d.ts

@@ -26,7 +26,7 @@ export interface ModelEntry {
     provider: string;
     model: string;
     displayName: string;
-    purposes: ModelPurpose[];
+    routeIntents: ModelPurpose[];
     baseUrl?: string;
     enabled: boolean;
     nativeModelId?: string;
@@ -36,11 +36,26 @@ export interface ModelEntry {
     streamRequired?: boolean;
     toolCall?: boolean;
     mediaType?: string | null;
-    capabilities?: string[];
+    capabilityProfile?: ModelCapabilityProfile;
     pricing?: Record<string, unknown>;
     /** Thinking-strength control class for the UI (see ReasoningMode). */
     reasoningMode?: ReasoningMode;
 }
+export interface ModelCapabilityProfile {
+    tasks?: string[];
+    input_modalities?: string[];
+    output_modalities?: string[];
+    traits?: string[];
+    verification?: {
+        state?: string;
+        source?: string;
+    };
+    cost?: {
+        tier?: string;
+        requires_confirmation?: boolean;
+        default_selectable?: boolean;
+    };
+}
 export type PurposeBindings = Partial<Record<ModelPurpose, string>>;
 export interface ModelRegistryConfig {
     providers: ProviderPoolConfig[];

package/dist/types/runtime/pet/pet-community-assets.d.ts

@@ -8,6 +8,19 @@ export interface InstalledCommunityPetResource {
     installDir: string;
     name: string;
     sanitized: boolean;
+    /** Number of declared asset files materialized to disk. */
+    assetCount: number;
 }
-export declare function installCommunityPetResource(install: CommunityInstallResolution): Promise<InstalledCommunityPetResource>;
+export interface InstallCommunityPetOptions {
+    fetchFn?: typeof fetch;
+    /** Replace an existing install in place (update flow) instead of erroring. */
+    allowReplace?: boolean;
+}
+/**
+ * Materialize a community pet end to end (WS-AD4): download the asset package,
+ * verify the whole-package sha256 (+ per-file sha256 when declared), unpack to a
+ * quarantine dir, then land it atomically at the install dir. Previously this only
+ * wrote manifest.json — the actual webp/animation bytes never reached disk.
+ */
+export declare function installCommunityPetResource(install: CommunityInstallResolution, options?: InstallCommunityPetOptions): Promise<InstalledCommunityPetResource>;
 export declare function assertPetInstall(install: CommunityInstallResolution): void;