priiisk 0.1.1

package/dist/chunk-FZICDHTN.js

@@ -0,0 +1,603 @@
+import { createRequire as __priiiskCreateRequire } from "node:module";
+const require = __priiiskCreateRequire(import.meta.url);
+import {
+  DoctorCheckStatus,
+  detectCampSurface,
+  doctorCheck,
+  doctorErrorMessage,
+  makeDoctorReport,
+  resolveCampSurface,
+  withCampRpc
+} from "./chunk-UCN75R46.js";
+import {
+  PI_RUNTIME_VERSION,
+  PiModelCatalogIssueCode,
+  inspectPiModelCatalog,
+  makePiOperatorResources
+} from "./chunk-YCBBC5MH.js";
+import {
+  CampHealthComponentStatus,
+  CampHealthOverallStatus,
+  CampHostReadiness,
+  CampLifecycle,
+  CampManifestInvalidError,
+  CampManifestVersionError,
+  FileSystem_exports,
+  PRIIISK_HOST_VERSION,
+  PRIIISK_PROTOCOL_PACKAGE_VERSION,
+  PRIIISK_PROTOCOL_VERSION,
+  SurfacePresence,
+  campControllerHealthComponents,
+  campHealthLiveness,
+  campManifestHostGeneration,
+  campProjectPaths,
+  campRecoveryDiagnosticFromCause,
+  findCampControllerHealthFailure,
+  findCampRecoveryHealthComponent,
+  listWorkerModelCatalogEntries,
+  loadCampHealth,
+  loadCampManifest,
+  loadWorkerConfig,
+  resolveCredentialsPath,
+  resolveProjectScope,
+  resolveWorkerConfigPath
+} from "./chunk-RJO6Z3SQ.js";
+import {
+  Clock_exports,
+  Effect_exports,
+  Option_exports,
+  Ref_exports
+} from "./chunk-KFSFN6L5.js";
+
+// packages/cli/src/doctor/environmentDoctor.ts
+import { dirname } from "node:path";
+var minimumNode = { major: 24, minor: 12 };
+var checkProjectScope = (project) => doctorCheck("project.scope", DoctorCheckStatus.pass, "Project scope resolved", {
+  cwd: project.cwd,
+  name: project.name,
+  hash: project.hash
+});
+var checkRuntime = () => {
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  const supported = major > minimumNode.major || major === minimumNode.major && minor >= minimumNode.minor;
+  return doctorCheck(
+    "runtime",
+    supported ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+    supported ? "Runtime versions available" : "Node runtime is too old",
+    {
+      nodeVersion: process.versions.node,
+      minimumNodeVersion: `${minimumNode.major}.${minimumNode.minor}`,
+      sessionRuntimeVersion: PI_RUNTIME_VERSION
+    }
+  );
+};
+var checkConfig = (fs) => Effect_exports.all([resolveWorkerConfigPath, loadWorkerConfig(fs)]).pipe(
+  Effect_exports.map(
+    ([path, config]) => config === void 0 ? doctorCheck("config", DoctorCheckStatus.warning, "User config is missing", { path }) : doctorCheck("config", DoctorCheckStatus.pass, "TOML config is valid", {
+      path,
+      schemaVersion: config.schemaVersion
+    })
+  ),
+  Effect_exports.catchAll(
+    (cause) => resolveWorkerConfigPath.pipe(
+      Effect_exports.map(
+        (path) => doctorCheck("config", DoctorCheckStatus.failure, "TOML config is invalid", {
+          path,
+          error: doctorErrorMessage(cause)
+        })
+      )
+    )
+  )
+);
+var inspectStorageEntry = (fs, entry) => fs.exists(entry.path).pipe(
+  Effect_exports.flatMap(
+    (exists) => exists ? fs.stat(entry.path).pipe(
+      Effect_exports.map((info) => ({
+        ...entry,
+        exists: true,
+        mode: info.mode & 511,
+        kindMatches: (info.mode & 61440) === entry.expectedMode,
+        private: (info.mode & 63) === 0
+      }))
+    ) : Effect_exports.succeed({
+      ...entry,
+      exists: false,
+      mode: void 0,
+      kindMatches: true,
+      private: true
+    })
+  )
+);
+var checkStorage = (fs, paths) => Effect_exports.all([resolveWorkerConfigPath, resolveCredentialsPath]).pipe(
+  Effect_exports.flatMap(
+    ([configPath, credentialsPath]) => Effect_exports.forEach(
+      [
+        { id: "state", path: paths.stateDir, expectedMode: 16384 },
+        { id: "quarantine", path: paths.quarantineDir, expectedMode: 16384 },
+        { id: "sessions", path: paths.sessionsDir, expectedMode: 16384 },
+        { id: "agent", path: paths.agentDir, expectedMode: 16384 },
+        { id: "logs", path: paths.logsDir, expectedMode: 16384 },
+        { id: "cache", path: paths.cacheDir, expectedMode: 16384 },
+        { id: "runtime", path: paths.runtimeDir, expectedMode: 16384 },
+        { id: "socket", path: paths.socketPath, expectedMode: 49152 },
+        { id: "lifecycle-lock", path: paths.lifecycleLockPath, expectedMode: 32768 },
+        { id: "manifest", path: paths.manifestPath, expectedMode: 32768 },
+        { id: "health", path: paths.healthPath, expectedMode: 32768 },
+        { id: "config-directory", path: dirname(configPath), expectedMode: 16384 },
+        {
+          id: "credentials-directory",
+          path: dirname(credentialsPath),
+          expectedMode: 16384
+        },
+        { id: "config", path: configPath, expectedMode: 32768 },
+        { id: "credentials", path: credentialsPath, expectedMode: 32768 }
+      ],
+      (entry) => inspectStorageEntry(fs, entry)
+    )
+  ),
+  Effect_exports.map((entries) => {
+    const invalid = entries.filter((entry) => !entry.private || !entry.kindMatches);
+    return doctorCheck(
+      "storage.permissions",
+      invalid.length === 0 ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+      invalid.length === 0 ? "Existing storage paths are private" : "Storage paths have unsafe permissions or unexpected kind",
+      {
+        entries: entries.map((entry) => ({
+          id: entry.id,
+          path: entry.path,
+          exists: entry.exists,
+          kindMatches: entry.kindMatches,
+          ...entry.mode === void 0 ? {} : { mode: `0${entry.mode.toString(8)}` }
+        }))
+      }
+    );
+  }),
+  Effect_exports.catchAll(
+    (cause) => Effect_exports.succeed(
+      doctorCheck("storage.permissions", DoctorCheckStatus.failure, "Storage check failed", {
+        error: doctorErrorMessage(cause)
+      })
+    )
+  )
+);
+
+// packages/cli/src/doctor/stateDoctor.ts
+var invalidManifestCheck = (path, cause) => {
+  const recovery = campRecoveryDiagnosticFromCause(cause);
+  if (cause instanceof CampManifestVersionError) {
+    return doctorCheck("manifest", DoctorCheckStatus.failure, recovery.summary, {
+      path,
+      errorCode: "unsupported_version",
+      recoveryCode: recovery.code,
+      expectedVersion: cause.expectedVersion,
+      receivedVersion: cause.receivedVersion,
+      recoveryAction: cause.receivedVersion === 1 ? "camp_up_fresh" : "upgrade_runtime"
+    });
+  }
+  if (cause instanceof CampManifestInvalidError) {
+    return doctorCheck("manifest", DoctorCheckStatus.failure, recovery.summary, {
+      path,
+      errorCode: cause.code,
+      recoveryCode: recovery.code,
+      error: doctorErrorMessage(cause)
+    });
+  }
+  return doctorCheck("manifest", DoctorCheckStatus.failure, recovery.summary, {
+    path,
+    errorCode: "state_io",
+    recoveryCode: recovery.code,
+    error: doctorErrorMessage(cause)
+  });
+};
+var checkManifest = (fs, paths, project) => loadCampManifest(fs, paths.manifestPath).pipe(
+  Effect_exports.map((manifest) => {
+    if (Option_exports.isNone(manifest)) {
+      return {
+        check: doctorCheck("manifest", DoctorCheckStatus.skipped, "Camp manifest is absent")
+      };
+    }
+    const value = manifest.value;
+    if (value.projectHash !== project.hash || value.projectCwd !== project.cwd) {
+      return {
+        check: doctorCheck(
+          "manifest",
+          DoctorCheckStatus.failure,
+          "Camp manifest belongs to another project scope",
+          {
+            path: paths.manifestPath,
+            manifestProjectHash: value.projectHash,
+            expectedProjectHash: project.hash
+          }
+        )
+      };
+    }
+    const status = value.lifecycle === CampLifecycle.starting ? DoctorCheckStatus.warning : DoctorCheckStatus.pass;
+    return {
+      check: doctorCheck("manifest", status, `Camp manifest is ${value.lifecycle}`, {
+        path: paths.manifestPath,
+        generation: campManifestHostGeneration(value) ?? null,
+        updatedAt: value.updatedAt
+      }),
+      manifest: value
+    };
+  }),
+  Effect_exports.catchAll(
+    (cause) => Effect_exports.succeed({
+      check: invalidManifestCheck(paths.manifestPath, cause)
+    })
+  )
+);
+var durableHealthFallback = (fs, paths, project, manifest, expectedLive) => Effect_exports.all([loadCampHealth(fs, paths.healthPath), Clock_exports.currentTimeMillis]).pipe(
+  Effect_exports.map(
+    ([snapshot, now]) => Option_exports.match(snapshot, {
+      onNone: () => doctorCheck(
+        "health.durable",
+        DoctorCheckStatus.skipped,
+        "Durable health snapshot is absent"
+      ),
+      onSome: (value) => {
+        const liveness = campHealthLiveness(value, now);
+        const matchesProject = value.projectHash === project.hash;
+        const manifestGeneration = manifest === void 0 ? void 0 : campManifestHostGeneration(manifest);
+        const matchesGeneration = manifestGeneration === void 0 || value.generation === manifestGeneration;
+        if (!matchesProject || !matchesGeneration) {
+          return doctorCheck(
+            "health.durable",
+            DoctorCheckStatus.failure,
+            "Durable health snapshot does not match camp identity",
+            {
+              path: paths.healthPath,
+              stale: true,
+              healthProjectHash: value.projectHash,
+              healthGeneration: value.generation
+            }
+          );
+        }
+        const recovery = findCampRecoveryHealthComponent(value);
+        if (recovery !== void 0) {
+          return doctorCheck(
+            "health.durable",
+            DoctorCheckStatus.failure,
+            recovery.message ?? recovery.code ?? "Camp recovery failed",
+            {
+              path: paths.healthPath,
+              stale: true,
+              recoveryCode: recovery.code,
+              recoverySummary: recovery.message,
+              snapshot: value
+            }
+          );
+        }
+        const controller = findCampControllerHealthFailure(value);
+        if (controller !== void 0) {
+          return doctorCheck(
+            "health.durable",
+            DoctorCheckStatus.failure,
+            controller.message ?? controller.code ?? `Controller component ${controller.id} failed`,
+            {
+              path: paths.healthPath,
+              stale: true,
+              controllerComponentId: controller.id,
+              ...controller.code === void 0 ? {} : { controllerCode: controller.code },
+              snapshot: value
+            }
+          );
+        }
+        if (expectedLive && liveness.stale) {
+          return doctorCheck(
+            "health.durable",
+            DoctorCheckStatus.failure,
+            `Health snapshot stopped updating ${String(Math.round(liveness.ageMs / 1e3))}s ago while the camp is ${manifest?.lifecycle ?? "running"}`,
+            {
+              path: paths.healthPath,
+              stale: true,
+              heartbeatAgeMs: liveness.ageMs,
+              snapshot: value
+            }
+          );
+        }
+        return doctorCheck(
+          "health.durable",
+          expectedLive ? DoctorCheckStatus.warning : DoctorCheckStatus.skipped,
+          `Stale health evidence: ${value.overallStatus}`,
+          {
+            path: paths.healthPath,
+            stale: true,
+            heartbeatAgeMs: liveness.ageMs,
+            snapshot: value
+          }
+        );
+      }
+    })
+  ),
+  Effect_exports.catchAll(
+    (cause) => Effect_exports.succeed(
+      doctorCheck(
+        "health.durable",
+        DoctorCheckStatus.failure,
+        "Durable health snapshot is invalid",
+        { path: paths.healthPath, error: doctorErrorMessage(cause) }
+      )
+    )
+  )
+);
+
+// packages/cli/src/doctor/hostDoctor.ts
+var failureTag = (cause) => {
+  if (typeof cause !== "object" || cause === null || !("_tag" in cause)) return void 0;
+  return typeof cause._tag === "string" ? cause._tag : void 0;
+};
+var isCompatibilityFailure = (cause) => {
+  const tag = failureTag(cause);
+  return tag === "ProtocolVersionMismatch" || tag === "ProjectScopeMismatch";
+};
+var controllerCheck = (health) => {
+  const components = campControllerHealthComponents(health);
+  const failed = components.filter(
+    (component) => component.status === CampHealthComponentStatus.failed
+  );
+  const degraded = components.filter(
+    (component) => component.status === CampHealthComponentStatus.degraded
+  );
+  const worst = failed[0] ?? degraded[0];
+  const status = failed.length > 0 ? DoctorCheckStatus.failure : degraded.length > 0 ? DoctorCheckStatus.warning : components.length === 0 ? DoctorCheckStatus.skipped : DoctorCheckStatus.pass;
+  return doctorCheck(
+    "controller",
+    status,
+    worst === void 0 ? components.length === 0 ? "Controller components are not reported" : "Controller journal, consumers and receipts are ready" : worst.message ?? worst.code ?? `Controller component ${worst.id} is ${worst.status}`,
+    {
+      ...worst?.code === void 0 ? {} : { code: worst.code },
+      components: components.map((component) => ({
+        id: component.id,
+        status: component.status,
+        ...component.code === void 0 ? {} : { code: component.code },
+        ...component.diagnostics === void 0 ? {} : { diagnostics: component.diagnostics }
+      }))
+    }
+  );
+};
+var checkHost = (fs, project, paths, manifest) => Effect_exports.gen(function* () {
+  const retryState = yield* Ref_exports.make([]);
+  const result = yield* Effect_exports.either(
+    withCampRpc(
+      ({ client, context }) => Effect_exports.all({
+        handshake: client.Handshake(context),
+        health: client.Health(context)
+      }),
+      {
+        operation: "doctor.host",
+        timeoutMs: 3e3,
+        retryTransientErrors: true,
+        onRetry: (diagnostic) => Ref_exports.update(retryState, (current) => [...current, diagnostic])
+      }
+    )
+  );
+  const retries = yield* Ref_exports.get(retryState);
+  if (result._tag === "Left") {
+    const compatibilityFailure = isCompatibilityFailure(result.left);
+    const expectedLive = compatibilityFailure || manifest?.lifecycle === CampLifecycle.running || manifest?.lifecycle === CampLifecycle.starting;
+    const error = doctorErrorMessage(result.left);
+    return [
+      doctorCheck(
+        "host",
+        expectedLive ? DoctorCheckStatus.failure : DoctorCheckStatus.skipped,
+        expectedLive ? "Camp host is unreachable" : "Camp host is not running",
+        { error, retries }
+      ),
+      doctorCheck(
+        "versions",
+        compatibilityFailure ? DoctorCheckStatus.failure : DoctorCheckStatus.skipped,
+        compatibilityFailure ? "Protocol or project mismatch detected" : "Host version check skipped",
+        compatibilityFailure ? { error, failureTag: failureTag(result.left) } : void 0
+      ),
+      yield* durableHealthFallback(fs, paths, project, manifest, expectedLive)
+    ];
+  }
+  const { handshake, health } = result.right;
+  const compatible = handshake.protocolVersion === PRIIISK_PROTOCOL_VERSION && handshake.hostVersion === PRIIISK_HOST_VERSION && handshake.projectHash === project.hash && health.projectHash === project.hash && health.generation === handshake.generation;
+  const hostStatus = handshake.readiness === CampHostReadiness.ready && retries.length === 0 ? DoctorCheckStatus.pass : DoctorCheckStatus.warning;
+  const healthStatus = health.overallStatus === CampHealthOverallStatus.failed ? DoctorCheckStatus.failure : health.overallStatus === CampHealthOverallStatus.degraded ? DoctorCheckStatus.warning : DoctorCheckStatus.pass;
+  const recovery = findCampRecoveryHealthComponent(health);
+  return [
+    controllerCheck(health),
+    doctorCheck(
+      "host",
+      hostStatus,
+      retries.length === 0 ? `Camp host is ${handshake.readiness}` : `Camp host recovered after ${String(retries.length)} retries`,
+      { socketPath: paths.socketPath, generation: handshake.generation, retries }
+    ),
+    doctorCheck(
+      "versions",
+      compatible ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+      compatible ? "CLI, host and protocol versions are compatible" : "Version mismatch detected",
+      {
+        protocolVersion: PRIIISK_PROTOCOL_VERSION,
+        protocolPackageVersion: PRIIISK_PROTOCOL_PACKAGE_VERSION,
+        hostVersion: PRIIISK_HOST_VERSION,
+        remoteProtocolVersion: handshake.protocolVersion,
+        remoteHostVersion: handshake.hostVersion
+      }
+    ),
+    doctorCheck(
+      "health.live",
+      recovery === void 0 ? healthStatus : DoctorCheckStatus.failure,
+      recovery?.message ?? `Live health is ${health.overallStatus}`,
+      {
+        stale: false,
+        ...recovery?.code === void 0 ? {} : { recoveryCode: recovery.code },
+        ...recovery?.message === void 0 ? {} : { recoverySummary: recovery.message },
+        snapshot: health
+      }
+    )
+  ];
+});
+
+// packages/cli/src/doctor/piDoctor.ts
+var skippedChecks = (summary, details) => [
+  doctorCheck("models.catalog", DoctorCheckStatus.skipped, summary, details),
+  doctorCheck("models.auth", DoctorCheckStatus.skipped, summary, details)
+];
+var checkPiModels = (fs) => Effect_exports.gen(function* () {
+  const configResult = yield* Effect_exports.either(loadWorkerConfig(fs));
+  if (configResult._tag === "Left") {
+    return skippedChecks("Model checks skipped because config is invalid", {
+      error: doctorErrorMessage(configResult.left)
+    });
+  }
+  if (configResult.right === void 0) {
+    return skippedChecks("Model checks skipped because config is missing");
+  }
+  const resourcesResult = yield* Effect_exports.either(makePiOperatorResources());
+  if (resourcesResult._tag === "Left") {
+    return [
+      doctorCheck(
+        "models.catalog",
+        DoctorCheckStatus.failure,
+        "Pi model catalog is unavailable",
+        { error: doctorErrorMessage(resourcesResult.left) }
+      ),
+      doctorCheck(
+        "models.auth",
+        DoctorCheckStatus.skipped,
+        "Model auth check skipped because catalog is unavailable"
+      )
+    ];
+  }
+  const inspection = inspectPiModelCatalog(
+    listWorkerModelCatalogEntries(configResult.right),
+    resourcesResult.right.modelRegistry,
+    { authDiagnosticCodes: resourcesResult.right.authDiagnosticCodes ?? [] }
+  );
+  const authIssues = inspection.issues.filter(
+    (issue) => issue.code === PiModelCatalogIssueCode.authMissing || issue.code === PiModelCatalogIssueCode.authUnavailable
+  );
+  const catalogIssues = inspection.issues.filter(
+    (issue) => issue.code !== PiModelCatalogIssueCode.authMissing && issue.code !== PiModelCatalogIssueCode.authUnavailable
+  );
+  const details = {
+    declaredCount: inspection.declaredCount,
+    providerCount: inspection.providerCount,
+    oauthModelCount: inspection.oauthModelCount
+  };
+  return [
+    doctorCheck(
+      "models.catalog",
+      catalogIssues.length === 0 ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+      catalogIssues.length === 0 ? "Configured models exist in the Pi catalog" : "Configured model catalog has invalid references",
+      { ...details, issues: catalogIssues }
+    ),
+    doctorCheck(
+      "models.auth",
+      authIssues.length === 0 ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+      authIssues.length === 0 ? "Configured model authentication is available" : authIssues.some((issue) => issue.code === PiModelCatalogIssueCode.authUnavailable) ? "Pi authentication storage is unavailable" : "Configured model authentication is missing",
+      { issues: authIssues }
+    )
+  ];
+});
+
+// packages/cli/src/doctor/surfaceDoctor.ts
+var inspectRunningSurface = (manifest) => {
+  const handle = manifest.surface;
+  if (handle === void 0) {
+    return Effect_exports.succeed(
+      doctorCheck("surface", DoctorCheckStatus.failure, "Running camp has no surface handle")
+    );
+  }
+  return resolveCampSurface(handle.providerAlias).pipe(
+    Effect_exports.flatMap(
+      (surface) => Effect_exports.all({
+        context: surface.detectContext(),
+        inspection: surface.inspect(handle)
+      })
+    ),
+    Effect_exports.map(({ context, inspection }) => {
+      const present = inspection.presence === SurfacePresence.present;
+      const sameContainer = context.containerRef === handle.containerRef;
+      return doctorCheck(
+        "surface",
+        present && sameContainer ? DoctorCheckStatus.pass : DoctorCheckStatus.failure,
+        !present ? "Camp surface is missing" : sameContainer ? "Camp surface and current context are available" : "Current surface context belongs to another container",
+        {
+          providerAlias: handle.providerAlias,
+          presence: inspection.presence,
+          focused: inspection.focused ?? false,
+          sameContainer
+        }
+      );
+    })
+  );
+};
+var inspectCurrentSurface = () => detectCampSurface().pipe(
+  Effect_exports.flatMap((surface) => surface.detectContext()),
+  Effect_exports.map(
+    (context) => doctorCheck("surface", DoctorCheckStatus.pass, "Surface context is available", {
+      providerAlias: context.providerAlias
+    })
+  )
+);
+var checkSurface = (manifest) => (manifest !== void 0 && manifest.lifecycle !== CampLifecycle.stopped ? inspectRunningSurface(manifest) : inspectCurrentSurface()).pipe(
+  Effect_exports.catchAll(
+    (cause) => Effect_exports.succeed(
+      doctorCheck("surface", DoctorCheckStatus.failure, "Surface context is unavailable", {
+        error: doctorErrorMessage(cause)
+      })
+    )
+  )
+);
+
+// packages/cli/src/doctor/doctorService.ts
+var runDoctor = Effect_exports.gen(function* () {
+  const fs = yield* FileSystem_exports.FileSystem;
+  const runtime = checkRuntime();
+  const config = yield* checkConfig(fs);
+  const piModels = yield* checkPiModels(fs);
+  const projectResult = yield* Effect_exports.either(resolveProjectScope);
+  if (projectResult._tag === "Left") {
+    const surface2 = yield* checkSurface();
+    const checkedAt2 = yield* Clock_exports.currentTimeMillis;
+    const skipped = [
+      doctorCheck("storage.permissions", DoctorCheckStatus.skipped, "Storage check skipped"),
+      doctorCheck("manifest", DoctorCheckStatus.skipped, "Manifest check skipped"),
+      doctorCheck("host", DoctorCheckStatus.skipped, "Host check skipped"),
+      doctorCheck("versions", DoctorCheckStatus.skipped, "Host version check skipped"),
+      doctorCheck("health.durable", DoctorCheckStatus.skipped, "Health check skipped")
+    ];
+    return makeDoctorReport(
+      [
+        doctorCheck("project.scope", DoctorCheckStatus.failure, "Project scope is invalid", {
+          error: doctorErrorMessage(projectResult.left)
+        }),
+        runtime,
+        config,
+        ...piModels,
+        surface2,
+        ...skipped
+      ],
+      checkedAt2
+    );
+  }
+  const project = projectResult.right;
+  const paths = campProjectPaths(project);
+  const storage = yield* checkStorage(fs, paths);
+  const manifestResult = yield* checkManifest(fs, paths, project);
+  const surface = yield* checkSurface(manifestResult.manifest);
+  const host = yield* checkHost(fs, project, paths, manifestResult.manifest);
+  const checkedAt = yield* Clock_exports.currentTimeMillis;
+  return makeDoctorReport(
+    [
+      checkProjectScope(project),
+      runtime,
+      config,
+      ...piModels,
+      storage,
+      manifestResult.check,
+      surface,
+      ...host
+    ],
+    checkedAt,
+    project.hash
+  );
+});
+export {
+  runDoctor
+};