@lesliechan721/aw 0.1.0-beta.10

package/dist/src/types.d.ts

@@ -0,0 +1,474 @@
+export type * from '@lesliechan721/aw-plugin-core/manifest';
+import type { ArtifactState, ArtifactTarget, CatalogChannel, CatalogManifestV7, CatalogSourceId, CliVersion, DistributionName, DynamicArtifactKind, ManagedArtifactId, PlatformName, PluginId, PluginVersion, Scope, SourceIdentity, TrackedHookGroupIdentity } from '@lesliechan721/aw-plugin-core/manifest';
+export type ArtifactSurface = {
+    kind: 'platform';
+    name: PlatformName;
+} | {
+    kind: 'distribution';
+    name: DistributionName;
+};
+export type PlatformSelection = PlatformName | 'both';
+export type CommandAction = 'install' | 'uninstall' | 'reinstall' | 'cleanup' | 'config' | 'status';
+export type RebuildCommand = 'install' | 'sync' | 'cleanup' | 'reinstall' | 'uninstall';
+export type RebuildActionName = 'preflight.inspect' | 'stale.cleanup' | 'native.write' | 'artifacts.write' | 'postApply' | 'postcheck.inspect' | 'marketplace.commit' | 'marketplace.rollback' | 'recovery.cleanup' | 'cleanup.owned';
+export type RebuildActionEventData = {
+    name: RebuildActionName;
+    phase: 'start';
+} | {
+    name: RebuildActionName;
+    phase: 'success';
+    durationMs: number;
+} | {
+    name: RebuildActionName;
+    phase: 'failure';
+    durationMs: number;
+    message?: string;
+};
+export interface RebuildActionEvent {
+    type: 'rebuild:action';
+    source: {
+        plugin: string;
+        platform: PlatformName;
+        scope: Scope;
+        action: RebuildCommand;
+    };
+    data: RebuildActionEventData;
+}
+export type StrictSemVerString = string;
+export type CatalogVersion = StrictSemVerString;
+export type AgentVersionStatus = 'supported' | 'missing' | 'probeFailed' | 'unparseable' | 'tooOld';
+export type AgentVersionReasonCode = 'agentVersionMissing' | 'agentVersionProbeFailed' | 'agentVersionUnparseable' | 'agentVersionTooLow';
+export type ConfigFieldKind = 'manifest';
+export type ConfigValueState = 'default' | 'configured' | 'invalid';
+export type NextStepKind = 'uiAction' | 'cliCommand' | 'manual';
+export type ManualNextStepKind = 'guidance' | 'blocker' | 'documentation';
+export type TargetWriteState = 'completed' | 'failed';
+export type ReceiptOverallState = 'succeeded' | 'failed';
+export type RebuildReceiptOverallState = ReceiptOverallState | 'partial';
+export type CatalogGitRefPolicy = {
+    type: 'explicit';
+    ref: string;
+} | {
+    type: 'cliChannel';
+};
+interface CatalogSourceBase {
+    id: CatalogSourceId;
+    primary: boolean;
+    autoCheck?: boolean;
+}
+export interface GitCatalogSource extends CatalogSourceBase {
+    type: 'git';
+    url: string;
+    refPolicy: CatalogGitRefPolicy;
+    subdir?: string;
+}
+export interface PathCatalogSource extends CatalogSourceBase {
+    type: 'path';
+    path: string;
+    managedBy?: {
+        kind: 'catalog-workspace';
+        workspaceIdentity: string;
+    };
+}
+export type CatalogSource = GitCatalogSource | PathCatalogSource;
+export interface CatalogSourcesConfig {
+    schemaVersion: 2;
+    sources: CatalogSource[];
+}
+export interface CatalogSourceResolution {
+    sourceId: CatalogSourceId;
+    sourceIdentity: SourceIdentity;
+    requestedRef: string;
+    resolvedCommit: string;
+    rootDir: string;
+    manifest: CatalogManifestV7;
+    manifestDigest: string;
+    snapshotDigest: string;
+    transport: 'git' | 'path';
+    cleanup(): Promise<void>;
+}
+export interface CatalogGenerationActiveV1 {
+    sourceConfigFingerprint: string;
+    sourceIdentity: SourceIdentity;
+    requestedRef: string;
+    resolvedCommit: string;
+    logicalIdentity: string;
+    manifestDigest: string;
+    snapshotDigest: string;
+    activatedAt: string;
+}
+export interface CatalogGenerationLastSyncV1 {
+    syncedAt: string;
+    mode: 'check' | 'sync';
+    state: 'succeeded' | 'failed';
+    resolvedCommit?: string;
+    errorCode?: string;
+}
+export interface CatalogSourceGenerationStateV1 {
+    active?: CatalogGenerationActiveV1;
+    lastSync?: CatalogGenerationLastSyncV1;
+}
+export interface CatalogGenerationStateFileV1 {
+    schemaVersion: 1;
+    sources: Record<string, CatalogSourceGenerationStateV1>;
+}
+export interface CatalogGenerationMetadataV1 {
+    schemaVersion: 1;
+    logicalIdentity: string;
+    catalogVersion: string;
+    channel: CatalogChannel;
+    manifestDigest: string;
+    snapshotDigest: string;
+    requiredAwCapabilities: string[];
+}
+export interface CatalogGenerationSyncEvidence {
+    sourceIdentity: SourceIdentity;
+    logicalIdentity: string;
+    catalogVersion: string;
+    channel: CatalogChannel;
+    requestedRef: string;
+    resolvedCommit: string;
+    manifestDigest: string;
+    snapshotDigest: string;
+}
+export interface CatalogGenerationCandidateEvidence extends CatalogGenerationSyncEvidence {
+    sourceConfigFingerprint: string;
+}
+export interface CatalogGenerationCandidateComparison {
+    matches: boolean;
+    changedFields: Array<keyof CatalogGenerationCandidateEvidence>;
+}
+export type CatalogActivationMode = 'normal' | 'explicitSourceChange' | 'exactRepair' | 'replaceDamaged';
+export type CatalogSourceImpactCategory = 'installation' | 'config' | 'lifecycle' | 'marketplace';
+export interface CatalogSourceImpactReference {
+    category: CatalogSourceImpactCategory;
+    sourceId: string;
+    pluginId?: string;
+    platform?: PlatformName;
+    scope?: Scope;
+    projectRecord?: 'current' | 'historical' | 'unknown';
+    marketplaceName?: string;
+}
+export interface CatalogSourcePluginChanges {
+    added: string[];
+    removed: string[];
+    changed: string[];
+    newlyIncompatible: string[];
+    dependencyChanged: string[];
+}
+export interface CatalogSourceImpactError {
+    code: 'stateInventoryFailed' | 'catalogManifestUnavailable';
+    kind: string;
+    relevance?: {
+        global: true;
+    } | {
+        global: false;
+        sourceId?: string;
+        pluginName?: string;
+        platform?: PlatformName;
+        scope?: Scope;
+    };
+}
+export interface CatalogSourceImpact {
+    impactSchemaVersion: 1;
+    sourceId: string;
+    inventoryComplete: boolean;
+    references: CatalogSourceImpactReference[];
+    affectedReferences: CatalogSourceImpactReference[];
+    changes: CatalogSourcePluginChanges;
+    errors: CatalogSourceImpactError[];
+}
+export interface CatalogGenerationSyncResult {
+    catalogGenerationSchemaVersion: 1;
+    sourceId: CatalogSourceId;
+    mode: 'check' | 'sync';
+    outcome: 'checked' | 'activated' | 'unchanged';
+    activeChanged: boolean;
+    resolution: CatalogGenerationSyncEvidence;
+    active?: CatalogGenerationActiveV1;
+    lastSync: CatalogGenerationLastSyncV1;
+    impact?: CatalogSourceImpact;
+}
+export interface CatalogGenerationSetSource {
+    sourceId: CatalogSourceId;
+    sourceConfigFingerprint: string;
+    sourceIdentity: SourceIdentity;
+    logicalIdentity: string;
+    catalogVersion: string;
+    resolvedCommit: string;
+    manifestDigest: string;
+    snapshotDigest: string;
+    storeKey: string;
+    snapshotPath: string;
+    manifest: CatalogManifestV7;
+}
+export interface CatalogGenerationSet {
+    generationSetDigest: string;
+    configDigest: string;
+    primarySourceId: CatalogSourceId;
+    sources: CatalogGenerationSetSource[];
+}
+export interface CatalogProviderRuntimeOptions {
+    cliVersion: CliVersion;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+}
+export interface NextStepInstruction {
+    kind: NextStepKind;
+    label: string;
+    description: string;
+    manualKind?: ManualNextStepKind;
+    uiAction?: string;
+    command?: string;
+}
+export interface NextStepsPayloadBoundary {
+    nextStepsSchemaVersion: 1;
+    nextSteps: NextStepInstruction[];
+    legacyNextSteps?: string[];
+}
+export interface ReceiptTargetIdentity {
+    pluginName: string;
+    pluginId?: PluginId;
+    marketplaceName?: string;
+    sourceId?: CatalogSourceId;
+    sourceIdentity?: SourceIdentity;
+    platform: PlatformName;
+    scope: Scope;
+    projectKey?: string;
+}
+export interface ReceiptTargetResult {
+    target: ReceiptTargetIdentity;
+    action: string;
+    state: TargetWriteState;
+    message?: string;
+    errorCode?: string;
+    relation?: 'requested' | 'dependency';
+    requiredBy?: string[];
+    recoveryActions?: string[];
+}
+export interface ConfigFieldEntry {
+    key: string;
+    title: string;
+    kind: ConfigFieldKind;
+    reserved: boolean;
+    writable: boolean;
+    valueState: ConfigValueState;
+    effectiveValue: unknown | null;
+    sourceLayer: 'default' | 'user' | 'project' | null;
+    storedValue?: unknown;
+    storedSourceLayer?: 'user' | 'project';
+    invalidOverride?: {
+        sourceLayer: 'default' | 'user' | 'project';
+        issues: unknown[];
+    };
+    fallback?: {
+        effectiveValue: unknown;
+        sourceLayer: 'default' | 'user' | 'project';
+    };
+    value: unknown | null;
+    source: 'default' | 'user' | 'project' | 'missing';
+    matchedPreset: string | null;
+    valid: boolean;
+    issues: unknown[];
+}
+export interface ConfigReceiptFieldEntry {
+    key: string;
+    title: string;
+    kind: ConfigFieldKind;
+    reserved: boolean;
+    action: 'set' | 'unset' | 'reset';
+    scope: Scope;
+    valueState?: ConfigValueState;
+}
+export declare const CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION = 6;
+export type ConfigMutationCommand = 'config:set' | 'config:unset' | 'config:reset';
+export interface ConfigMutationReceiptBase<Command extends ConfigMutationCommand = ConfigMutationCommand> {
+    receiptSchemaVersion: typeof CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION;
+    command: Command;
+    ok: boolean;
+    overallState: RebuildReceiptOverallState;
+}
+export interface ConfigSchemaEvidence {
+    source: 'currentCatalog';
+    identity: string;
+    pluginVersion: PluginVersion;
+    manifestDigest: string;
+}
+export type PortablePluginRelation = 'requested' | 'direct' | 'transitive';
+export interface PortableSkillCandidate {
+    name: string;
+    description: string;
+    providerPluginId: PluginId;
+    providerDisplayName: string;
+    relation: PortablePluginRelation;
+    dynamic: boolean;
+    filesDigest: string;
+}
+export interface ArtifactPlanBase {
+    version: 2;
+    artifacts: ArtifactPlanArtifact[];
+}
+export type ArtifactPlan = ArtifactPlanBase;
+export interface ArtifactPlanArtifactBase {
+    id: ManagedArtifactId;
+    platform?: PlatformName;
+    distribution?: DistributionName;
+    target: ArtifactTarget;
+    kind: DynamicArtifactKind;
+    state: ArtifactState;
+    refreshKeys: string[];
+    disabledReason?: string;
+}
+export interface DeveloperInstructionsBlockArtifact extends ArtifactPlanArtifactBase {
+    target: 'codex.developerInstructionsBlock';
+    kind: 'instruction';
+    content?: string;
+}
+export interface CodexAgentRoleArtifact extends ArtifactPlanArtifactBase {
+    target: 'codex.agentRole';
+    kind: 'codexRole';
+    roleKey?: string;
+    content?: {
+        registration?: {
+            description?: string;
+        };
+        roleFile?: {
+            name?: string;
+            description?: string;
+            developer_instructions?: string;
+            model?: string;
+            model_reasoning_effort?: string;
+        };
+    };
+}
+export interface CodexSkillArtifact extends ArtifactPlanArtifactBase {
+    target: 'codex.skill';
+    kind: 'skill';
+    skillKey?: string;
+    content?: {
+        files?: Record<string, string>;
+    };
+}
+export interface ClaudeSkillArtifact extends ArtifactPlanArtifactBase {
+    target: 'claude.skill';
+    kind: 'skill';
+    skillKey?: string;
+    content?: {
+        files?: Record<string, string>;
+    };
+}
+export interface AgentSkillsSkillArtifact extends ArtifactPlanArtifactBase {
+    distribution: 'agent-skills';
+    target: 'agent-skills.skill';
+    kind: 'skill';
+    skillKey: string;
+    content?: {
+        files?: Record<string, string>;
+    };
+}
+export type ArtifactPlanArtifact = DeveloperInstructionsBlockArtifact | CodexAgentRoleArtifact | CodexSkillArtifact | ClaudeSkillArtifact | AgentSkillsSkillArtifact;
+export interface GeneratedArtifact {
+    path: string;
+    paths?: string[];
+    kind: 'instruction' | 'permission' | 'hook' | 'agent' | 'skill' | 'mcpServer';
+    platform: PlatformName;
+    artifactKey?: string;
+    hookGroups?: TrackedHookGroupIdentity[];
+    id?: ManagedArtifactId;
+    target?: ArtifactTarget;
+    state?: ArtifactState;
+    disabledReason?: string;
+    refreshKeys?: string[];
+    configDigest?: string;
+    contentDigest?: string;
+    roleKey?: string;
+}
+export interface AgentVersionRequirement {
+    platform: PlatformName;
+    command: string;
+    displayName: string;
+    minVersion: StrictSemVerString;
+}
+export interface CodexOperationRequirement {
+    scope: Scope;
+    minimumVersion: StrictSemVerString;
+    requiresProjectPluginContract: boolean;
+}
+export interface AgentVersionProbeResult {
+    platform: PlatformName;
+    command: string;
+    status: AgentVersionStatus;
+    requiredMinVersion: StrictSemVerString;
+    detectedVersion?: StrictSemVerString;
+    reasonCode?: AgentVersionReasonCode;
+    stdout: string;
+    stderr: string;
+    rawOutput: string;
+    exitCode?: number;
+    details?: string;
+}
+export interface AgentVersionGateFailure {
+    platform: PlatformName;
+    command: CommandAction | string;
+    probeCommand: string;
+    status: Exclude<AgentVersionStatus, 'supported'>;
+    reasonCode: AgentVersionReasonCode;
+    detectedVersion?: StrictSemVerString;
+    requiredMinVersion: StrictSemVerString;
+    failureReason: string;
+    suggestedAction: string;
+    rawVersionOutput?: string;
+}
+export interface AgentVersionGateErrorPayload {
+    command: CommandAction | string;
+    failures: AgentVersionGateFailure[];
+}
+export interface CommandOptions {
+    scope: Scope;
+    platform: PlatformSelection;
+    cwd: string;
+    scriptTimeoutMs?: number;
+    allowManagedCodexInstall?: boolean;
+    yes?: boolean;
+}
+export interface DependencyScopeOverride {
+    pluginId: string;
+    platform: PlatformName;
+    scope: Scope;
+}
+export interface DependencyScopeSelector {
+    pluginId: string;
+    platform?: PlatformName;
+    scope: Scope;
+}
+export interface InstallCommandOptions extends CommandOptions {
+    dependencyScopeOverrides?: DependencyScopeSelector[];
+}
+export interface StatusCommandOptions {
+    cwd: string;
+    scope?: Scope;
+    platform?: PlatformName | 'both';
+    verbose?: boolean;
+    json?: boolean;
+}
+export declare class CommandWarningError extends Error {
+    readonly warnings: string[];
+    readonly exitCode: number;
+    constructor(message: string, options?: {
+        warnings?: string[];
+        exitCode?: number;
+    });
+}
+export declare function isCommandWarningError(error: unknown): error is CommandWarningError;
+export declare class AgentVersionGateError extends Error {
+    readonly code = "AGENT_VERSION_GATE_FAILED";
+    readonly payload: AgentVersionGateErrorPayload;
+    constructor(message: string, payload: AgentVersionGateErrorPayload);
+}
+export declare function isAgentVersionGateError(error: unknown): error is AgentVersionGateError;
+export interface CatalogResolution {
+    rootDir: string;
+    source: 'local' | 'embedded';
+    channel?: CatalogChannel;
+    catalogVersion?: CatalogVersion;
+}

package/dist/src/types.js

@@ -0,0 +1,34 @@
+export const CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION = 6;
+export class CommandWarningError extends Error {
+    warnings;
+    exitCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'CommandWarningError';
+        this.warnings = [...new Set(options.warnings ?? [])];
+        this.exitCode = options.exitCode ?? 1;
+    }
+}
+export function isCommandWarningError(error) {
+    return (error instanceof Error &&
+        error.name === 'CommandWarningError' &&
+        Array.isArray(error.warnings) &&
+        typeof error.exitCode === 'number');
+}
+export class AgentVersionGateError extends Error {
+    code = 'AGENT_VERSION_GATE_FAILED';
+    payload;
+    constructor(message, payload) {
+        super(message);
+        this.name = 'AgentVersionGateError';
+        this.payload = payload;
+    }
+}
+export function isAgentVersionGateError(error) {
+    return (error instanceof Error &&
+        error.name === 'AgentVersionGateError' &&
+        typeof error.code === 'string' &&
+        typeof error.payload === 'object' &&
+        Array.isArray(error.payload.failures));
+}
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAmWA,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,CAAC;AA4MxD,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnC,QAAQ,CAAW;IACnB,QAAQ,CAAS;IAE1B,YACE,OAAe,EACf,UAGI,EAAE;QAEN,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC;IACxC,CAAC;CACF;AAED,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,OAAO,CACL,KAAK,YAAY,KAAK;QACtB,KAAK,CAAC,IAAI,KAAK,qBAAqB;QACpC,KAAK,CAAC,OAAO,CAAE,KAA6B,CAAC,QAAQ,CAAC;QACtD,OAAQ,KAA6B,CAAC,QAAQ,KAAK,QAAQ,CAC5D,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IACrC,IAAI,GAAG,2BAA2B,CAAC;IACnC,OAAO,CAA+B;IAE/C,YACE,OAAe,EACf,OAAqC;QAErC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAED,MAAM,UAAU,uBAAuB,CAAC,KAAc;IACpD,OAAO,CACL,KAAK,YAAY,KAAK;QACtB,KAAK,CAAC,IAAI,KAAK,uBAAuB;QACtC,OAAQ,KAA+B,CAAC,IAAI,KAAK,QAAQ;QACzD,OAAQ,KAA+B,CAAC,OAAO,KAAK,QAAQ;QAC5D,KAAK,CAAC,OAAO,CAAE,KAA+B,CAAC,OAAO,CAAC,QAAQ,CAAC,CACjE,CAAC;AACJ,CAAC"}

package/dist/src/utils/agent-version.d.ts

@@ -0,0 +1,19 @@
+import type { AgentVersionProbeResult, AgentVersionRequirement, CodexOperationRequirement, PlatformName, Scope } from '../types.js';
+import { type NativeCliRunner } from './native-cli.js';
+export interface ProbeAgentVersionOptions {
+    argsPrefix?: string[];
+    cache?: boolean;
+    command?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    minimumVersion?: string;
+    runner?: NativeCliRunner;
+    timeoutMs?: number;
+}
+export declare function getMinimumAgentVersion(platform: PlatformName): string;
+export declare function getAgentVersionRequirement(platform: PlatformName): AgentVersionRequirement;
+export declare function getCodexOperationRequirement(scope: Scope): CodexOperationRequirement;
+export declare function extractStrictSemVerTokenFromVersionOutput(output: string): string | null;
+export declare function probeAgentVersion(platform: PlatformName, options?: ProbeAgentVersionOptions): Promise<AgentVersionProbeResult>;
+export declare function probeCodexOperationVersion(requirement: CodexOperationRequirement, options?: Omit<ProbeAgentVersionOptions, 'minimumVersion'>): Promise<AgentVersionProbeResult>;
+export declare function clearAgentVersionProbeCacheForTests(): void;