yeka-skills 0.1.0

package/dist/cli.js

@@ -0,0 +1,1735 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands.ts
+import { chmod as chmod2, lstat as lstat6, mkdir as mkdir4, mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
+import os6 from "os";
+import path7 from "path";
+
+// ../contracts/dist/index.js
+import { z } from "zod";
+var skillNamePattern = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+var opaqueShareIdPattern = /^[A-Za-z0-9_-]{22}$/;
+var SkillNameSchema = z.string().regex(skillNamePattern);
+var OpaqueShareIdSchema = z.string().regex(opaqueShareIdPattern);
+var SkillLaneSchema = z.enum(["shared", "codex", "claude"]);
+var RuntimeSchema = z.enum(["codex", "claude"]);
+var SkillSourceSchema = z.object({
+  repository: z.string().min(1),
+  commit: z.string().regex(/^[0-9a-f]{40}$/),
+  path: z.string().min(1),
+  contentHash: z.string().regex(/^[0-9a-f]{64}$/),
+  updatedAt: z.iso.datetime({ offset: true })
+});
+var SkillArtifactSchema = z.object({
+  key: z.string().startsWith("registry/v1/artifacts/"),
+  sha256: z.string().regex(/^[0-9a-f]{64}$/),
+  sizeBytes: z.number().int().positive().max(25 * 1024 * 1024)
+});
+var RegistrySkillSchema = z.object({
+  name: SkillNameSchema,
+  opaqueId: OpaqueShareIdSchema,
+  sourceDescription: z.string().min(1).max(4e3),
+  lane: SkillLaneSchema,
+  runtimes: z.array(RuntimeSchema).min(1).max(2),
+  source: SkillSourceSchema,
+  artifact: SkillArtifactSchema
+});
+var ShareIdMapSchema = z.object({
+  schemaVersion: z.literal(1),
+  skills: z.record(SkillNameSchema, OpaqueShareIdSchema)
+});
+var RegistryManifestSchema = z.object({
+  schemaVersion: z.literal(1),
+  generatedAt: z.iso.datetime({ offset: true }),
+  sourceRepository: z.string().min(1),
+  sourceCommit: z.string().regex(/^[0-9a-f]{40}$/),
+  skills: z.array(RegistrySkillSchema).min(1)
+});
+var InstallReceiptSchema = z.object({
+  schemaVersion: z.literal(1),
+  skillName: SkillNameSchema,
+  runtime: RuntimeSchema,
+  targetRoot: z.string().min(1),
+  installedPath: z.string().min(1),
+  sourceCommit: z.string().regex(/^[0-9a-f]{40}$/),
+  sourceHash: z.string().regex(/^[0-9a-f]{64}$/),
+  artifactSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  installedHash: z.string().regex(/^[0-9a-f]{64}$/),
+  installedAt: z.iso.datetime({ offset: true })
+});
+var TokenResponseSchema = z.object({
+  accessToken: z.string().min(32),
+  tokenType: z.literal("Bearer"),
+  expiresIn: z.number().int().positive().max(28800)
+});
+var ApiErrorSchema = z.object({
+  error: z.object({
+    code: z.string().min(1),
+    message: z.string().min(1),
+    requestId: z.string().uuid()
+  })
+});
+
+// src/config.ts
+import os from "os";
+import path from "path";
+var REGISTRY_ORIGIN = "https://registry.yekaskills.com";
+var KEYCHAIN_SERVICE = "com.gemography.yeka-skills.cli";
+var KEYCHAIN_ACCOUNT = "registry-session";
+var localPaths = (home = os.homedir()) => {
+  const applicationSupport = path.join(home, "Library", "Application Support", "Yeka Skills");
+  return {
+    applicationSupport,
+    backups: path.join(applicationSupport, "backups"),
+    cache: path.join(home, "Library", "Caches", "Yeka Skills"),
+    receipts: path.join(applicationSupport, "receipts")
+  };
+};
+
+// src/errors.ts
+var CliError = class extends Error {
+  code;
+  exitCode;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = options?.exitCode ?? 1;
+  }
+};
+var AuthenticationError = class extends CliError {
+  constructor(message = "Your Yeka Skills session has expired.") {
+    super("authentication_required", message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/installer.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import {
+  chmod,
+  cp,
+  lstat as lstat3,
+  mkdir as mkdir3,
+  mkdtemp,
+  rename as rename2,
+  rm as rm2,
+  stat
+} from "fs/promises";
+import os3 from "os";
+import path5 from "path";
+
+// ../integrity/dist/index.js
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { lstat, readdir } from "fs/promises";
+import path2 from "path";
+var MAX_SKILL_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_SKILL_TOTAL_BYTES = 25 * 1024 * 1024;
+var MAX_SKILL_FILE_COUNT = 2e3;
+var hashFile = async (filePath) => {
+  const hash = createHash("sha256");
+  const stream = createReadStream(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+};
+var assertSafeRelativePath = (value) => {
+  if (value.length === 0 || value.includes("\0") || value.includes("\\")) {
+    throw new Error(`Unsafe relative path: ${JSON.stringify(value)}`);
+  }
+  const normalized = path2.posix.normalize(value);
+  const segments = value.split("/");
+  if (path2.posix.isAbsolute(value) || normalized !== value || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error(`Unsafe relative path: ${JSON.stringify(value)}`);
+  }
+  return value;
+};
+var collectFiles = async (root, current, entries) => {
+  const directoryEntries = await readdir(current, { withFileTypes: true });
+  directoryEntries.sort((left, right) => left.name.localeCompare(right.name, "en"));
+  let totalBytes = 0;
+  for (const directoryEntry of directoryEntries) {
+    const absolutePath = path2.join(current, directoryEntry.name);
+    const relativePath = assertSafeRelativePath(path2.relative(root, absolutePath).split(path2.sep).join("/"));
+    const fileStat = await lstat(absolutePath);
+    if (fileStat.isSymbolicLink()) {
+      throw new Error(`Symbolic links are not allowed in skill artifacts: ${relativePath}`);
+    }
+    if (fileStat.isDirectory()) {
+      totalBytes += await collectFiles(root, absolutePath, entries);
+      continue;
+    }
+    if (!fileStat.isFile()) {
+      throw new Error(`Unsupported filesystem entry in skill artifact: ${relativePath}`);
+    }
+    if (fileStat.size > MAX_SKILL_FILE_BYTES) {
+      throw new Error(`Skill file exceeds the ${MAX_SKILL_FILE_BYTES} byte limit: ${relativePath}`);
+    }
+    entries.push({
+      path: relativePath,
+      sizeBytes: fileStat.size,
+      executable: (fileStat.mode & 73) !== 0,
+      sha256: await hashFile(absolutePath)
+    });
+    if (entries.length > MAX_SKILL_FILE_COUNT) {
+      throw new Error(`Skill contains more than ${MAX_SKILL_FILE_COUNT} files`);
+    }
+    totalBytes += fileStat.size;
+    if (totalBytes > MAX_SKILL_TOTAL_BYTES) {
+      throw new Error(`Skill content exceeds the ${MAX_SKILL_TOTAL_BYTES} byte limit`);
+    }
+  }
+  return totalBytes;
+};
+var hashDirectory = async (root) => {
+  const rootStat = await lstat(root);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw new Error(`Skill root must be a real directory: ${root}`);
+  }
+  const entries = [];
+  const totalBytes = await collectFiles(root, root, entries);
+  const hash = createHash("sha256");
+  hash.update("yeka-skill-tree-v1\0");
+  for (const entry of entries) {
+    hash.update(`${JSON.stringify(entry)}
+`);
+  }
+  return {
+    contentHash: hash.digest("hex"),
+    entries,
+    totalBytes
+  };
+};
+
+// src/archive.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { lstat as lstat2, mkdir, rm } from "fs/promises";
+import path3 from "path";
+import * as tar from "tar";
+var MAX_ARCHIVE_ENTRY_COUNT = MAX_SKILL_FILE_COUNT * 2;
+var MAX_ARCHIVE_DEPTH = 64;
+var MAX_ARCHIVE_PATH_BYTES = 4096;
+var normalizeEntryPath = (entry) => {
+  const value = entry.type === "Directory" ? entry.path.replace(/\/+$/, "") : entry.path;
+  if (value.length === 0) {
+    throw new CliError("unsafe_archive", "The skill archive contains an empty path.");
+  }
+  if (Buffer.byteLength(value, "utf8") > MAX_ARCHIVE_PATH_BYTES) {
+    throw new CliError("unsafe_archive", "The skill archive contains a path that is too long.");
+  }
+  if (/[\u0000-\u001f\u007f]/u.test(value)) {
+    throw new CliError("unsafe_archive", "The skill archive contains a path with control characters.");
+  }
+  try {
+    assertSafeRelativePath(value);
+  } catch (error) {
+    throw new CliError("unsafe_archive", `The skill archive contains an unsafe path: ${value}`, {
+      cause: error
+    });
+  }
+  if (value.split("/").length > MAX_ARCHIVE_DEPTH) {
+    throw new CliError("unsafe_archive", "The skill archive contains a path that is too deep.");
+  }
+  return value;
+};
+var inspectEntry = (entry) => {
+  if (entry.type !== "File" && entry.type !== "Directory") {
+    throw new CliError(
+      "unsafe_archive",
+      `The skill archive contains an unsupported ${entry.type} entry.`
+    );
+  }
+  const archivePath = normalizeEntryPath(entry);
+  if (entry.linkpath !== void 0 && entry.linkpath.length > 0) {
+    throw new CliError("unsafe_archive", `The skill archive contains a link at ${archivePath}.`);
+  }
+  if (entry.mode !== void 0 && (entry.mode & 3584) !== 0) {
+    throw new CliError("unsafe_archive", `The skill archive contains unsafe mode bits at ${archivePath}.`);
+  }
+  if (!Number.isSafeInteger(entry.size) || entry.size < 0) {
+    throw new CliError("unsafe_archive", `The skill archive contains an invalid size at ${archivePath}.`);
+  }
+  if (entry.type === "Directory" && entry.size !== 0) {
+    throw new CliError("unsafe_archive", `The skill archive contains an invalid directory at ${archivePath}.`);
+  }
+  if (entry.type === "File" && entry.size > MAX_SKILL_FILE_BYTES) {
+    throw new CliError("unsafe_archive", `The skill archive contains an oversized file at ${archivePath}.`);
+  }
+  return { path: archivePath, type: entry.type, sizeBytes: entry.size };
+};
+var assertNoPathConflicts = (entries) => {
+  const files = new Set(entries.filter((entry) => entry.type === "File").map((entry) => entry.path));
+  for (const entry of entries) {
+    const segments = entry.path.split("/");
+    for (let index = 1; index < segments.length; index += 1) {
+      if (files.has(segments.slice(0, index).join("/"))) {
+        throw new CliError("unsafe_archive", "The skill archive contains conflicting paths.");
+      }
+    }
+    if (entry.type === "Directory" && files.has(entry.path)) {
+      throw new CliError("unsafe_archive", "The skill archive contains conflicting paths.");
+    }
+  }
+};
+var inspectArchive = async (archivePath) => {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  let fileCount = 0;
+  let totalBytes = 0;
+  try {
+    await new Promise((resolve, reject) => {
+      const input = createReadStream2(archivePath);
+      const parser = new tar.Parser({
+        strict: true,
+        maxDecompressionRatio: 1e3
+      });
+      let settled = false;
+      const fail = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        input.destroy();
+        reject(error);
+      };
+      parser.on("error", fail);
+      input.on("error", fail);
+      parser.on("entry", (rawEntry) => {
+        try {
+          const entry = inspectEntry(rawEntry);
+          if (seen.has(entry.path)) {
+            throw new CliError("unsafe_archive", `The skill archive repeats ${entry.path}.`);
+          }
+          seen.add(entry.path);
+          entries.push(entry);
+          if (entries.length > MAX_ARCHIVE_ENTRY_COUNT) {
+            throw new CliError("unsafe_archive", "The skill archive contains too many entries.");
+          }
+          if (entry.type === "File") {
+            fileCount += 1;
+            totalBytes += entry.sizeBytes;
+          }
+          if (fileCount > MAX_SKILL_FILE_COUNT || totalBytes > MAX_SKILL_TOTAL_BYTES) {
+            throw new CliError("unsafe_archive", "The skill archive exceeds its content limits.");
+          }
+          rawEntry.resume();
+        } catch (error) {
+          fail(error);
+          parser.abort(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+      parser.on("end", () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      });
+      input.pipe(parser);
+    });
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError("invalid_archive", "The downloaded skill archive is invalid.", { cause: error });
+  }
+  if (fileCount === 0 || !seen.has("SKILL.md")) {
+    throw new CliError("invalid_archive", "The skill archive does not contain a SKILL.md file.");
+  }
+  assertNoPathConflicts(entries);
+  return { entries, fileCount, totalBytes };
+};
+var assertDestinationMissing = async (destination) => {
+  try {
+    await lstat2(destination);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  throw new CliError("staging_conflict", `The private staging path already exists: ${destination}`);
+};
+var extractVerifiedArchive = async (archivePath, destination, expectedContentHash) => {
+  await inspectArchive(archivePath);
+  await assertDestinationMissing(destination);
+  await mkdir(path3.dirname(destination), { recursive: true, mode: 448 });
+  await mkdir(destination, { mode: 448 });
+  try {
+    let extractionError;
+    await tar.x({
+      cwd: destination,
+      file: archivePath,
+      strict: true,
+      preserveOwner: false,
+      preservePaths: false,
+      noMtime: true,
+      unlink: true,
+      chmod: true,
+      processUmask: 18,
+      maxDepth: MAX_ARCHIVE_DEPTH,
+      maxDecompressionRatio: 1e3,
+      filter: (_archivePath, rawEntry) => {
+        try {
+          inspectEntry(rawEntry);
+          return true;
+        } catch (error) {
+          extractionError = error instanceof CliError ? error : new CliError("unsafe_archive", "The skill archive changed during extraction.", {
+            cause: error
+          });
+          return false;
+        }
+      }
+    });
+    if (extractionError !== void 0) {
+      throw extractionError;
+    }
+    const integrity = await hashDirectory(destination);
+    if (integrity.contentHash !== expectedContentHash) {
+      throw new CliError(
+        "content_integrity_failed",
+        "The extracted skill content does not match its signed manifest."
+      );
+    }
+  } catch (error) {
+    await rm(destination, { recursive: true, force: true });
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError("archive_extract_failed", "The CLI could not extract the skill archive.", {
+      cause: error
+    });
+  }
+};
+
+// src/receipts.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile, readdir as readdir2, rename, unlink, writeFile } from "fs/promises";
+import os2 from "os";
+import path4 from "path";
+var rootIdentifier = (targetRoot) => createHash2("sha256").update(targetRoot).digest("hex").slice(0, 16);
+var receiptPath = (targetRoot, skillName, home = os2.homedir()) => path4.join(localPaths(home).receipts, rootIdentifier(targetRoot), `${skillName}.json`);
+var writeReceipt = async (receipt, home = os2.homedir()) => {
+  const validated = InstallReceiptSchema.parse(receipt);
+  const destination = receiptPath(receipt.targetRoot, receipt.skillName, home);
+  const directory = path4.dirname(destination);
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  const temporary = path4.join(directory, `.${receipt.skillName}.${randomUUID()}.tmp`);
+  await writeFile(temporary, `${JSON.stringify(validated, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  try {
+    await rename(temporary, destination);
+  } finally {
+    await unlink(temporary).catch(() => void 0);
+  }
+};
+var deleteReceipt = async (targetRoot, skillName, home = os2.homedir()) => {
+  await unlink(receiptPath(targetRoot, skillName, home)).catch((error) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  });
+};
+var readReceipt = async (targetRoot, skillName, home = os2.homedir()) => {
+  try {
+    return InstallReceiptSchema.parse(
+      JSON.parse(await readFile(receiptPath(targetRoot, skillName, home), "utf8"))
+    );
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw new CliError("invalid_receipt", `The local receipt for ${skillName} is invalid.`, {
+      cause: error
+    });
+  }
+};
+var listReceipts = async (home = os2.homedir()) => {
+  const root = localPaths(home).receipts;
+  let rootEntries;
+  try {
+    rootEntries = await readdir2(root, { withFileTypes: true });
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const receipts = [];
+  for (const rootEntry of rootEntries) {
+    if (!rootEntry.isDirectory()) {
+      continue;
+    }
+    const files = await readdir2(path4.join(root, rootEntry.name), { withFileTypes: true });
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".json")) {
+        continue;
+      }
+      try {
+        receipts.push(
+          InstallReceiptSchema.parse(
+            JSON.parse(await readFile(path4.join(root, rootEntry.name, file.name), "utf8"))
+          )
+        );
+      } catch (error) {
+        throw new CliError("invalid_receipt", `The local receipt ${file.name} is invalid.`, {
+          cause: error
+        });
+      }
+    }
+  }
+  return receipts.sort(
+    (left, right) => `${left.skillName}:${left.runtime}`.localeCompare(`${right.skillName}:${right.runtime}`, "en")
+  );
+};
+
+// src/installer.ts
+var isNotFound = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var fingerprint = async (entryPath) => {
+  try {
+    const entry = await lstat3(entryPath, { bigint: true });
+    return {
+      dev: entry.dev,
+      ino: entry.ino,
+      mode: Number(entry.mode),
+      mtimeNs: entry.mtimeNs,
+      size: entry.size
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+};
+var fingerprintsMatch = (left, right) => left !== null && right !== void 0 && left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.mtimeNs === right.mtimeNs && left.size === right.size;
+var allowedTargetRoots = (runtime, home) => runtime === "codex" ? [path5.join(home, ".agents", "skills"), path5.join(home, ".codex", "skills")] : [path5.join(home, ".claude", "skills")];
+var assertSafeTarget = async (target, skillName, home) => {
+  const resolvedRoot = path5.resolve(target.targetRoot);
+  if (!allowedTargetRoots(target.runtime, home).some((root) => path5.resolve(root) === resolvedRoot)) {
+    throw new CliError("unsafe_target", `The ${target.runtime} installation target is not supported.`);
+  }
+  const parent = path5.dirname(resolvedRoot);
+  let parentStat;
+  try {
+    parentStat = await lstat3(parent);
+  } catch (error) {
+    if (isNotFound(error)) {
+      throw new CliError("runtime_not_found", `The ${target.runtime} configuration directory is missing.`);
+    }
+    throw error;
+  }
+  if (!parentStat.isDirectory() || parentStat.isSymbolicLink()) {
+    throw new CliError("unsafe_target", `The ${target.runtime} configuration directory is not a real directory.`);
+  }
+  const rootFingerprint = await fingerprint(resolvedRoot);
+  if (rootFingerprint !== null) {
+    const rootStat = await lstat3(resolvedRoot);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+      throw new CliError("unsafe_target", `The ${target.runtime} skills directory is not a real directory.`);
+    }
+  }
+  const installedPath = path5.resolve(resolvedRoot, skillName);
+  if (path5.dirname(installedPath) !== resolvedRoot) {
+    throw new CliError("unsafe_target", "The skill installation path is unsafe.");
+  }
+};
+var targetsFromReceipts = (receipts, skillName, home = os3.homedir()) => {
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const receipt of receipts) {
+    if (receipt.skillName !== skillName) {
+      continue;
+    }
+    const allowed = allowedTargetRoots(receipt.runtime, home).map((root2) => path5.resolve(root2));
+    const root = path5.resolve(receipt.targetRoot);
+    const installed = path5.resolve(receipt.installedPath);
+    if (!allowed.includes(root) || installed !== path5.join(root, skillName)) {
+      throw new CliError("invalid_receipt_target", `The local receipt for ${skillName} has an unsafe target.`);
+    }
+    const key = `${receipt.runtime}:${root}`;
+    if (!seen.has(key)) {
+      targets.push({
+        runtime: receipt.runtime,
+        targetRoot: root,
+        legacy: root === path5.resolve(home, ".codex", "skills")
+      });
+      seen.add(key);
+    }
+  }
+  return targets;
+};
+var preflightTarget = async (target, skill, home) => {
+  await assertSafeTarget(target, skill.name, home);
+  const targetRoot = path5.resolve(target.targetRoot);
+  const installedPath = path5.join(targetRoot, skill.name);
+  const oldReceipt = await readReceipt(targetRoot, skill.name, home);
+  if (oldReceipt !== null && (oldReceipt.runtime !== target.runtime || path5.resolve(oldReceipt.targetRoot) !== targetRoot || path5.resolve(oldReceipt.installedPath) !== installedPath)) {
+    throw new CliError("invalid_receipt_target", `The local receipt for ${skill.name} has an invalid target.`);
+  }
+  const entryFingerprint = await fingerprint(installedPath);
+  if (entryFingerprint === null) {
+    return {
+      action: "install",
+      runtime: target.runtime,
+      targetRoot,
+      installedPath,
+      existed: false,
+      oldReceipt
+    };
+  }
+  if (oldReceipt === null) {
+    return {
+      action: "replace-unmanaged",
+      runtime: target.runtime,
+      targetRoot,
+      installedPath,
+      existed: true,
+      fingerprint: entryFingerprint,
+      oldReceipt
+    };
+  }
+  const installedStat = await lstat3(installedPath);
+  if (!installedStat.isDirectory() || installedStat.isSymbolicLink()) {
+    throw new CliError(
+      "local_changes",
+      `The managed ${skill.name} installation for ${target.runtime} is no longer a real directory. It was not changed.`
+    );
+  }
+  let currentHash;
+  try {
+    currentHash = (await hashDirectory(installedPath)).contentHash;
+  } catch (error) {
+    throw new CliError(
+      "local_changes",
+      `The managed ${skill.name} installation for ${target.runtime} contains unsupported local changes. It was not changed.`,
+      { cause: error }
+    );
+  }
+  if (currentHash !== oldReceipt.installedHash) {
+    throw new CliError(
+      "local_changes",
+      `The managed ${skill.name} installation for ${target.runtime} has local changes. It was not changed.`
+    );
+  }
+  const current = oldReceipt.sourceHash === skill.source.contentHash && oldReceipt.artifactSha256 === skill.artifact.sha256 && currentHash === skill.source.contentHash;
+  return {
+    action: current ? "unchanged" : "update",
+    runtime: target.runtime,
+    targetRoot,
+    installedPath,
+    existed: true,
+    fingerprint: entryFingerprint,
+    oldReceipt
+  };
+};
+var ensureTargetRoot = async (targetRoot) => {
+  try {
+    await mkdir3(targetRoot, { mode: 493 });
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+      throw error;
+    }
+  }
+  const rootStat = await lstat3(targetRoot);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw new CliError("unsafe_target", `The skills target is not a real directory: ${targetRoot}`);
+  }
+};
+var assertNoTargetRace = async (target) => {
+  const current = await fingerprint(target.installedPath);
+  if (target.existed ? !fingerprintsMatch(current, target.fingerprint) : current !== null) {
+    throw new CliError(
+      "target_changed",
+      `The ${target.runtime} installation changed during the operation. Nothing was overwritten.`
+    );
+  }
+  if (target.oldReceipt !== null && target.existed) {
+    const currentHash = (await hashDirectory(target.installedPath)).contentHash;
+    if (currentHash !== target.oldReceipt.installedHash) {
+      throw new CliError(
+        "target_changed",
+        `The ${target.runtime} installation changed during the operation. Nothing was overwritten.`
+      );
+    }
+  }
+};
+var backupDestination = (home, now, batchId, target) => {
+  const timestamp = now.toISOString().replace(/[:.]/g, "-");
+  const targetId = createHash3("sha256").update(target.targetRoot).digest("hex").slice(0, 16);
+  return path5.join(
+    localPaths(home).backups,
+    `${timestamp}-${batchId}`,
+    target.runtime,
+    targetId,
+    path5.basename(target.installedPath)
+  );
+};
+var rollbackMutations = async (mutations) => {
+  const failures = [];
+  for (const mutation of [...mutations].reverse()) {
+    try {
+      if (mutation.installedNew) {
+        await rm2(mutation.target.installedPath, { recursive: true, force: true });
+      }
+      if (mutation.backedUp && mutation.target.backupPath !== void 0) {
+        await rename2(mutation.target.backupPath, mutation.target.installedPath);
+      }
+    } catch (error) {
+      failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  return failures;
+};
+var restoreReceipts = async (targets, home) => {
+  const failures = [];
+  for (const target of targets) {
+    try {
+      if (target.oldReceipt === null) {
+        await deleteReceipt(target.targetRoot, path5.basename(target.installedPath), home);
+      } else {
+        await writeReceipt(target.oldReceipt, home);
+      }
+    } catch (error) {
+      failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  return failures;
+};
+var newReceipt = (target, skill, installedAt) => ({
+  schemaVersion: 1,
+  skillName: skill.name,
+  runtime: target.runtime,
+  targetRoot: target.targetRoot,
+  installedPath: target.installedPath,
+  sourceCommit: skill.source.commit,
+  sourceHash: skill.source.contentHash,
+  artifactSha256: skill.artifact.sha256,
+  installedHash: skill.source.contentHash,
+  installedAt
+});
+var installSkillFromArchive = async (options) => {
+  const home = path5.resolve(options.home ?? os3.homedir());
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  if (options.targets.length === 0) {
+    throw new CliError("runtime_not_found", "There is no supported target for this skill.");
+  }
+  const uniqueTargets = /* @__PURE__ */ new Set();
+  for (const target of options.targets) {
+    const key = `${target.runtime}:${path5.resolve(target.targetRoot)}`;
+    if (uniqueTargets.has(key)) {
+      throw new CliError("duplicate_target", "The installation target list contains a duplicate.");
+    }
+    uniqueTargets.add(key);
+  }
+  const operationCache = localPaths(home).cache;
+  await mkdir3(operationCache, { recursive: true, mode: 448 });
+  const cacheStat = await lstat3(operationCache);
+  if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) {
+    throw new CliError("unsafe_cache", "The Yeka Skills cache is not a real directory.");
+  }
+  const operationRoot = await mkdtemp(path5.join(operationCache, "install-"));
+  await chmod(operationRoot, 448);
+  const extractedPath = path5.join(operationRoot, "content");
+  try {
+    await extractVerifiedArchive(options.archivePath, extractedPath, options.skill.source.contentHash);
+    const preflight = await Promise.all(
+      options.targets.map((target) => preflightTarget(target, options.skill, home))
+    );
+    if (options.dryRun === true || preflight.every((target) => target.action === "unchanged")) {
+      return preflight.map(({ action, runtime, targetRoot, installedPath }) => ({
+        action,
+        runtime,
+        targetRoot,
+        installedPath
+      }));
+    }
+    const mutableTargets = preflight.filter((target) => target.action !== "unchanged");
+    try {
+      for (const target of mutableTargets) {
+        await ensureTargetRoot(target.targetRoot);
+        target.stagedPath = path5.join(
+          target.targetRoot,
+          `.yeka-stage-${options.skill.name}-${randomUUID2()}`
+        );
+        await cp(extractedPath, target.stagedPath, {
+          recursive: true,
+          force: false,
+          errorOnExist: true,
+          preserveTimestamps: false
+        });
+        const stagedHash = (await hashDirectory(target.stagedPath)).contentHash;
+        if (stagedHash !== options.skill.source.contentHash) {
+          throw new CliError("staging_integrity_failed", "A staged skill copy failed its integrity check.");
+        }
+      }
+      const batchId = randomUUID2();
+      const mutations = [];
+      const writtenReceipts = [];
+      try {
+        for (const target of mutableTargets) {
+          await assertNoTargetRace(target);
+          const mutation = { target, backedUp: false, installedNew: false };
+          mutations.push(mutation);
+          if (target.existed) {
+            target.backupPath = backupDestination(home, now, batchId, target);
+            await mkdir3(path5.dirname(target.backupPath), { recursive: true, mode: 448 });
+            const backupParent = await stat(path5.dirname(target.backupPath));
+            if (!backupParent.isDirectory()) {
+              throw new CliError("backup_failed", "The CLI could not create its private backup directory.");
+            }
+            await rename2(target.installedPath, target.backupPath);
+            mutation.backedUp = true;
+          }
+          if (target.stagedPath === void 0) {
+            throw new CliError("staging_failed", "The CLI lost a staged skill copy.");
+          }
+          await rename2(target.stagedPath, target.installedPath);
+          mutation.installedNew = true;
+          const installedHash = (await hashDirectory(target.installedPath)).contentHash;
+          if (installedHash !== options.skill.source.contentHash) {
+            throw new CliError("install_integrity_failed", "An installed skill failed its final integrity check.");
+          }
+        }
+        const installedAt = now.toISOString();
+        for (const target of mutableTargets) {
+          await writeReceipt(newReceipt(target, options.skill, installedAt), home);
+          writtenReceipts.push(target);
+        }
+      } catch (error) {
+        const receiptFailures = await restoreReceipts(writtenReceipts, home);
+        const rollbackFailures = await rollbackMutations(mutations);
+        if (receiptFailures.length > 0 || rollbackFailures.length > 0) {
+          throw new CliError(
+            "rollback_failed",
+            "The installation failed, and automatic rollback was incomplete. The backups were preserved.",
+            { cause: error }
+          );
+        }
+        throw error;
+      }
+      return preflight.map(({ action, runtime, targetRoot, installedPath, backupPath }) => ({
+        action,
+        runtime,
+        targetRoot,
+        installedPath,
+        ...backupPath === void 0 ? {} : { backupPath }
+      }));
+    } finally {
+      for (const target of mutableTargets) {
+        if (target.stagedPath !== void 0) {
+          await rm2(target.stagedPath, { recursive: true, force: true });
+        }
+      }
+    }
+  } finally {
+    await rm2(operationRoot, { recursive: true, force: true });
+  }
+};
+
+// src/keychain.ts
+import { spawn } from "child_process";
+import { createHash as createHash4 } from "crypto";
+var KEYCHAIN_CHUNK_CHARACTERS = 96;
+var MAX_SESSION_CHARACTERS = 4096;
+var MAX_SESSION_CHUNKS = Math.ceil(MAX_SESSION_CHARACTERS / KEYCHAIN_CHUNK_CHARACTERS);
+var MANIFEST_PATTERN = /^v1:([1-9][0-9]*):([0-9a-f]{64})$/;
+var sessionDigest = (value) => createHash4("sha256").update(value).digest("hex");
+var keychainPasswordInput = (password) => {
+  if (password.length === 0 || password.includes("\n") || password.includes("\r")) {
+    throw new CliError(
+      "invalid_keychain_value",
+      "The registry session cannot be saved safely in macOS Keychain."
+    );
+  }
+  return `${password}
+${password}
+`;
+};
+var securitySpawnOptions = {
+  // Without a new session, `security` reads from the user's controlling
+  // terminal instead of the private stdin pipe and leaves the CLI waiting.
+  detached: true,
+  stdio: ["pipe", "pipe", "pipe"],
+  windowsHide: true
+};
+var encodeSessionForKeychain = (token) => {
+  keychainPasswordInput(token);
+  if (token.length > MAX_SESSION_CHARACTERS) {
+    throw new CliError(
+      "invalid_keychain_value",
+      "The registry session cannot be saved safely in macOS Keychain."
+    );
+  }
+  const chunks = [];
+  for (let offset = 0; offset < token.length; offset += KEYCHAIN_CHUNK_CHARACTERS) {
+    chunks.push(token.slice(offset, offset + KEYCHAIN_CHUNK_CHARACTERS));
+  }
+  return {
+    chunks,
+    manifest: `v1:${chunks.length}:${sessionDigest(token)}`
+  };
+};
+var parseManifest = (manifest) => {
+  const match = MANIFEST_PATTERN.exec(manifest);
+  if (match === null) {
+    return null;
+  }
+  const count = Number(match[1]);
+  if (!Number.isSafeInteger(count) || count < 1 || count > MAX_SESSION_CHUNKS) {
+    return null;
+  }
+  return { count, digest: match[2] };
+};
+var decodeSessionFromKeychain = (manifest, chunks) => {
+  const parsed = parseManifest(manifest);
+  if (parsed === null || chunks.length !== parsed.count) {
+    return null;
+  }
+  const token = chunks.join("");
+  if (token.length === 0 || token.length > MAX_SESSION_CHARACTERS || token.includes("\n") || token.includes("\r") || sessionDigest(token) !== parsed.digest) {
+    return null;
+  }
+  return token;
+};
+var chunkAccount = (index) => `${KEYCHAIN_ACCOUNT}.${index}`;
+var runSecurity = (args, input) => new Promise((resolve, reject) => {
+  const child = spawn("/usr/bin/security", args, securitySpawnOptions);
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  child.on("error", reject);
+  child.on("close", (code) => {
+    resolve({
+      code: code ?? 1,
+      stdout: Buffer.concat(stdout).toString("utf8"),
+      stderr: Buffer.concat(stderr).toString("utf8")
+    });
+  });
+  if (input !== void 0) {
+    child.stdin.end(keychainPasswordInput(input));
+  } else {
+    child.stdin.end();
+  }
+});
+var readPassword = async (account) => {
+  const result = await runSecurity([
+    "find-generic-password",
+    "-a",
+    account,
+    "-s",
+    KEYCHAIN_SERVICE,
+    "-w"
+  ]);
+  if (result.code === 44) {
+    return null;
+  }
+  if (result.code !== 0) {
+    throw new CliError("keychain_read_failed", "The CLI could not read its macOS Keychain session.");
+  }
+  const value = result.stdout.trim();
+  return value.length === 0 ? null : value;
+};
+var writePassword = async (account, label, value) => {
+  const result = await runSecurity(
+    [
+      "add-generic-password",
+      "-U",
+      "-a",
+      account,
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-l",
+      label,
+      "-w"
+    ],
+    value
+  );
+  if (result.code !== 0) {
+    throw new CliError("keychain_write_failed", "The CLI could not save its macOS Keychain session.");
+  }
+};
+var deletePassword = async (account) => {
+  const result = await runSecurity([
+    "delete-generic-password",
+    "-a",
+    account,
+    "-s",
+    KEYCHAIN_SERVICE
+  ]);
+  if (result.code === 44) {
+    return false;
+  }
+  if (result.code !== 0) {
+    throw new CliError("keychain_delete_failed", "The CLI could not remove its macOS Keychain session.");
+  }
+  return true;
+};
+var readSession = async () => {
+  const manifest = await readPassword(KEYCHAIN_ACCOUNT);
+  if (manifest === null) {
+    return null;
+  }
+  const parsed = parseManifest(manifest);
+  if (parsed === null) {
+    await deletePassword(KEYCHAIN_ACCOUNT);
+    return null;
+  }
+  const chunks = await Promise.all(
+    Array.from({ length: parsed.count }, (_value, index) => readPassword(chunkAccount(index)))
+  );
+  if (chunks.some((chunk) => chunk === null)) {
+    await deleteSession();
+    return null;
+  }
+  const token = decodeSessionFromKeychain(manifest, chunks);
+  if (token === null) {
+    await deleteSession();
+  }
+  return token;
+};
+var writeSession = async (token) => {
+  const encoded = encodeSessionForKeychain(token);
+  await deleteSession();
+  let writtenChunks = 0;
+  try {
+    await writePassword(KEYCHAIN_ACCOUNT, "Yeka Skills CLI session", encoded.manifest);
+    for (const [index, chunk] of encoded.chunks.entries()) {
+      await writePassword(
+        chunkAccount(index),
+        `Yeka Skills CLI session part ${index + 1}`,
+        chunk
+      );
+      writtenChunks += 1;
+    }
+  } catch (error) {
+    await deletePassword(KEYCHAIN_ACCOUNT).catch(() => false);
+    await Promise.all(
+      Array.from(
+        { length: writtenChunks },
+        (_value, index) => deletePassword(chunkAccount(index)).catch(() => false)
+      )
+    );
+    throw error;
+  }
+};
+var deleteSession = async () => {
+  const manifest = await readPassword(KEYCHAIN_ACCOUNT);
+  const count = manifest === null ? 0 : parseManifest(manifest)?.count ?? 0;
+  const deletedManifest = await deletePassword(KEYCHAIN_ACCOUNT);
+  const deletedChunks = await Promise.all(
+    Array.from({ length: count }, (_value, index) => deletePassword(chunkAccount(index)))
+  );
+  return deletedManifest || deletedChunks.some(Boolean);
+};
+
+// src/local-status.ts
+import { lstat as lstat4 } from "fs/promises";
+import os4 from "os";
+var isNotFound2 = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var inspectLocalStatus = async (receipt, remote, home = os4.homedir()) => {
+  targetsFromReceipts([receipt], receipt.skillName, home);
+  let installedStat;
+  try {
+    installedStat = await lstat4(receipt.installedPath);
+  } catch (error) {
+    if (isNotFound2(error)) {
+      return { kind: "missing", receipt, ...remote === void 0 ? {} : { remote } };
+    }
+    throw error;
+  }
+  if (!installedStat.isDirectory() || installedStat.isSymbolicLink()) {
+    return { kind: "modified", receipt, ...remote === void 0 ? {} : { remote } };
+  }
+  let currentHash;
+  try {
+    currentHash = (await hashDirectory(receipt.installedPath)).contentHash;
+  } catch {
+    return { kind: "modified", receipt, ...remote === void 0 ? {} : { remote } };
+  }
+  if (currentHash !== receipt.installedHash) {
+    return { kind: "modified", receipt, ...remote === void 0 ? {} : { remote } };
+  }
+  if (remote === void 0) {
+    return { kind: "unavailable", receipt };
+  }
+  if (receipt.sourceHash !== remote.source.contentHash || receipt.artifactSha256 !== remote.artifact.sha256) {
+    return { kind: "update-available", receipt, remote };
+  }
+  return { kind: "current", receipt, remote };
+};
+
+// src/login.ts
+import { createHash as createHash5, randomBytes, timingSafeEqual } from "crypto";
+import { execFile } from "child_process";
+import http from "http";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_TOKEN_RESPONSE_BYTES = 16 * 1024;
+var AUTHORIZATION_CODE_PATTERN = /^[A-Za-z0-9._-]{32,4096}$/;
+var readBoundedJson = async (response) => {
+  const declared = response.headers.get("Content-Length");
+  if (declared !== null && (!/^(?:0|[1-9][0-9]*)$/.test(declared) || Number(declared) > MAX_TOKEN_RESPONSE_BYTES)) {
+    await response.body?.cancel("token response exceeds limit");
+    throw new CliError("token_response_too_large", "The registry token response is larger than allowed.");
+  }
+  if (response.body === null) {
+    throw new CliError("empty_token_response", "The registry returned an empty token response.");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    total += result.value.byteLength;
+    if (total > MAX_TOKEN_RESPONSE_BYTES) {
+      await reader.cancel("token response exceeds limit");
+      throw new CliError("token_response_too_large", "The registry token response is larger than allowed.");
+    }
+    chunks.push(result.value);
+  }
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
+  } catch (error) {
+    throw new CliError("invalid_token_response", "The registry returned an invalid token response.", {
+      cause: error
+    });
+  }
+};
+var constantTimeEqual = (left, right) => {
+  const leftHash = createHash5("sha256").update(left).digest();
+  const rightHash = createHash5("sha256").update(right).digest();
+  return timingSafeEqual(leftHash, rightHash);
+};
+var successPage = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'"><title>Yeka Skills login complete</title><style>html{color-scheme:dark;background:#151515;color:#f3f0e8;font:18px/1.5 system-ui,sans-serif}body{display:grid;min-height:100vh;margin:0;place-items:center}main{max-width:32rem;padding:2rem}</style></head><body><main><h1>Login complete</h1><p>You can close this page and return to your terminal.</p></main></body></html>`;
+var waitForCallback = async (expectedState) => {
+  let resolveCallback;
+  let rejectCallback;
+  const callback = new Promise((resolve, reject) => {
+    resolveCallback = resolve;
+    rejectCallback = reject;
+  });
+  const server = http.createServer((request, response) => {
+    const address2 = server.address();
+    if (typeof address2 === "string" || address2 === null) {
+      response.writeHead(500).end();
+      return;
+    }
+    const redirectUri = `http://127.0.0.1:${address2.port}/callback`;
+    const url = new URL(request.url ?? "/", redirectUri);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (request.method !== "GET" || url.origin !== new URL(redirectUri).origin || url.pathname !== "/callback" || code === null || !AUTHORIZATION_CODE_PATTERN.test(code) || state === null || !constantTimeEqual(state, expectedState)) {
+      response.writeHead(400, {
+        "Cache-Control": "no-store",
+        "Content-Type": "text/plain; charset=utf-8",
+        "X-Content-Type-Options": "nosniff"
+      });
+      response.end("The Yeka Skills login response is invalid.");
+      return;
+    }
+    response.writeHead(200, {
+      "Cache-Control": "no-store",
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'",
+      "Content-Type": "text/html; charset=utf-8",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff"
+    });
+    response.end(successPage);
+    resolveCallback?.({ code, redirectUri });
+  });
+  server.on("clientError", (_error, socket) => socket.destroy());
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  if (typeof address === "string" || address === null) {
+    server.close();
+    throw new CliError("login_listener_failed", "The CLI could not start its private login listener.");
+  }
+  const timeout = setTimeout(() => {
+    rejectCallback?.(new CliError("login_timeout", "The browser login did not finish within five minutes."));
+  }, LOGIN_TIMEOUT_MS);
+  timeout.unref();
+  return {
+    callback,
+    authorizationUrl: `http://127.0.0.1:${address.port}/callback`,
+    close: async () => {
+      clearTimeout(timeout);
+      if (!server.listening) {
+        return;
+      }
+      await new Promise(
+        (resolve, reject) => server.close((error) => error === void 0 ? resolve() : reject(error))
+      );
+    }
+  };
+};
+var openBrowser = async (url) => {
+  try {
+    await execFileAsync("/usr/bin/open", [url]);
+    return true;
+  } catch (error) {
+    void error;
+    return false;
+  }
+};
+var login = async () => {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash5("sha256").update(verifier).digest("base64url");
+  const state = randomBytes(32).toString("base64url");
+  const listener = await waitForCallback(state);
+  const authorizationUrl = new URL("/authorize", REGISTRY_ORIGIN);
+  authorizationUrl.searchParams.set("code_challenge", challenge);
+  authorizationUrl.searchParams.set("code_challenge_method", "S256");
+  authorizationUrl.searchParams.set("redirect_uri", listener.authorizationUrl);
+  authorizationUrl.searchParams.set("state", state);
+  process.stdout.write("Your browser will open for Gemography email verification.\n");
+  try {
+    if (!await openBrowser(authorizationUrl.toString())) {
+      process.stdout.write(`Open this address in your browser:
+${authorizationUrl.toString()}
+`);
+    }
+    const callback = await listener.callback;
+    const response = await fetch(new URL("/v1/auth/token", REGISTRY_ORIGIN), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        code: callback.code,
+        codeVerifier: verifier,
+        redirectUri: callback.redirectUri
+      }),
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) {
+      throw new CliError("token_exchange_failed", "The registry did not accept the browser login.");
+    }
+    const token = TokenResponseSchema.parse(await readBoundedJson(response)).accessToken;
+    await writeSession(token);
+    process.stdout.write("Login complete. The short session is stored in macOS Keychain.\n");
+    return token;
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError("login_failed", "The browser login did not complete.", { cause: error });
+  } finally {
+    await listener.close();
+  }
+};
+
+// src/registry-client.ts
+import { createHash as createHash6 } from "crypto";
+import { open, unlink as unlink2 } from "fs/promises";
+var MAX_MANIFEST_BYTES = 1024 * 1024;
+var parseContentLength = (value) => {
+  if (value === null) {
+    return null;
+  }
+  if (!/^(?:0|[1-9][0-9]*)$/.test(value)) {
+    throw new CliError("invalid_content_length", "The registry returned an invalid content length.");
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new CliError("invalid_content_length", "The registry returned an invalid content length.");
+  }
+  return parsed;
+};
+var readBoundedText = async (response, limit) => {
+  const declared = parseContentLength(response.headers.get("Content-Length"));
+  if (declared !== null && declared > limit) {
+    throw new CliError("response_too_large", "The registry response is larger than allowed.");
+  }
+  if (response.body === null) {
+    throw new CliError("empty_response", "The registry returned an empty response.");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    total += result.value.byteLength;
+    if (total > limit) {
+      await reader.cancel("response exceeds limit");
+      throw new CliError("response_too_large", "The registry response is larger than allowed.");
+    }
+    chunks.push(result.value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+};
+var assertRegistryResponse = async (response) => {
+  if (response.status === 401 || response.status === 403) {
+    await response.body?.cancel("authentication failed");
+    throw new AuthenticationError();
+  }
+  if (!response.ok) {
+    await response.body?.cancel("registry request failed");
+    throw new CliError(
+      "registry_request_failed",
+      `The registry request failed with status ${response.status}.`
+    );
+  }
+};
+var RegistryClient = class {
+  origin;
+  constructor(origin = REGISTRY_ORIGIN) {
+    this.origin = new URL(origin);
+    if (this.origin.protocol !== "https:" && this.origin.hostname !== "127.0.0.1") {
+      throw new CliError("unsafe_registry_origin", "The registry address must use HTTPS.");
+    }
+  }
+  async getManifest(token) {
+    const response = await fetch(new URL("/v1/manifest", this.origin), {
+      headers: { Authorization: `Bearer ${token}` },
+      redirect: "error",
+      signal: AbortSignal.timeout(3e4)
+    });
+    await assertRegistryResponse(response);
+    try {
+      return RegistryManifestSchema.parse(
+        JSON.parse(await readBoundedText(response, MAX_MANIFEST_BYTES))
+      );
+    } catch (error) {
+      if (error instanceof CliError) {
+        throw error;
+      }
+      throw new CliError("invalid_manifest", "The registry manifest is invalid.", { cause: error });
+    }
+  }
+  async downloadArtifact(skill, token, destination) {
+    const response = await fetch(
+      new URL(`/v1/skills/${encodeURIComponent(skill.name)}/archive`, this.origin),
+      {
+        headers: { Authorization: `Bearer ${token}` },
+        redirect: "error",
+        signal: AbortSignal.timeout(2 * 60 * 1e3)
+      }
+    );
+    await assertRegistryResponse(response);
+    if (response.body === null) {
+      throw new CliError("empty_artifact", "The registry returned an empty skill artifact.");
+    }
+    const declaredLength = parseContentLength(response.headers.get("Content-Length"));
+    if (declaredLength !== null && declaredLength !== skill.artifact.sizeBytes) {
+      await response.body.cancel("artifact size does not match manifest");
+      throw new CliError("artifact_size_mismatch", "The skill artifact size does not match its manifest.");
+    }
+    const file = await open(destination, "wx", 384);
+    const hash = createHash6("sha256");
+    const reader = response.body.getReader();
+    let bytesWritten = 0;
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done) {
+          break;
+        }
+        bytesWritten += result.value.byteLength;
+        if (bytesWritten > skill.artifact.sizeBytes) {
+          await reader.cancel("artifact exceeds manifest size");
+          throw new CliError(
+            "artifact_size_mismatch",
+            "The skill artifact is larger than its manifest allows."
+          );
+        }
+        hash.update(result.value);
+        let offset = 0;
+        while (offset < result.value.byteLength) {
+          const writeResult = await file.write(
+            result.value,
+            offset,
+            result.value.byteLength - offset,
+            null
+          );
+          if (writeResult.bytesWritten === 0) {
+            throw new CliError("artifact_write_failed", "The CLI could not save the skill artifact.");
+          }
+          offset += writeResult.bytesWritten;
+        }
+      }
+      await file.close();
+    } catch (error) {
+      await file.close().catch(() => void 0);
+      await unlink2(destination).catch(() => void 0);
+      throw error;
+    }
+    const digest = hash.digest("hex");
+    const responseDigest = response.headers.get("X-Yeka-Artifact-Sha256");
+    if (bytesWritten !== skill.artifact.sizeBytes || digest !== skill.artifact.sha256 || responseDigest !== null && responseDigest !== skill.artifact.sha256) {
+      await unlink2(destination).catch(() => void 0);
+      throw new CliError(
+        "artifact_integrity_failed",
+        "The downloaded skill artifact failed its integrity check."
+      );
+    }
+  }
+};
+
+// src/session.ts
+var defaultDependencies = { deleteSession, login, readSession };
+var withRegistrySession = async (operation, dependencies = defaultDependencies) => {
+  let token = await dependencies.readSession();
+  if (token === null) {
+    token = await dependencies.login();
+  }
+  try {
+    return await operation(token);
+  } catch (error) {
+    if (!(error instanceof AuthenticationError)) {
+      throw error;
+    }
+    await dependencies.deleteSession();
+    const renewedToken = await dependencies.login();
+    return operation(renewedToken);
+  }
+};
+
+// src/targets.ts
+import { lstat as lstat5 } from "fs/promises";
+import os5 from "os";
+import path6 from "path";
+var isRealDirectory = async (candidate) => {
+  try {
+    const entry = await lstat5(candidate);
+    return entry.isDirectory() && !entry.isSymbolicLink();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+var pathExists = async (candidate) => {
+  try {
+    await lstat5(candidate);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+var resolveCodexTarget = async (home, skillName) => {
+  const currentRoot = path6.join(home, ".agents", "skills");
+  const currentParent = path6.join(home, ".agents");
+  const codexConfig = path6.join(home, ".codex");
+  const legacyRoot = path6.join(codexConfig, "skills");
+  const legacyActive = await isRealDirectory(legacyRoot);
+  const currentActive = await isRealDirectory(currentRoot) || await isRealDirectory(currentParent) || await isRealDirectory(codexConfig) && !legacyActive;
+  if (currentActive) {
+    if (legacyActive && await pathExists(path6.join(legacyRoot, skillName))) {
+      throw new CliError(
+        "legacy_codex_conflict",
+        `Codex can see a legacy copy at ${path6.join(legacyRoot, skillName)}. Remove or archive that copy before installation.`
+      );
+    }
+    return { runtime: "codex", targetRoot: currentRoot, legacy: false };
+  }
+  if (legacyActive) {
+    return { runtime: "codex", targetRoot: legacyRoot, legacy: true };
+  }
+  return null;
+};
+var resolveClaudeTarget = async (home) => {
+  const claudeConfig = path6.join(home, ".claude");
+  if (!await isRealDirectory(claudeConfig)) {
+    return null;
+  }
+  return {
+    runtime: "claude",
+    targetRoot: path6.join(claudeConfig, "skills"),
+    legacy: false
+  };
+};
+var resolveInstallTargets = async (skill, home = os5.homedir()) => {
+  const targets = [];
+  if (skill.runtimes.includes("codex")) {
+    const codex = await resolveCodexTarget(home, skill.name);
+    if (codex !== null) {
+      targets.push(codex);
+    }
+  }
+  if (skill.runtimes.includes("claude")) {
+    const claude = await resolveClaudeTarget(home);
+    if (claude !== null) {
+      targets.push(claude);
+    }
+  }
+  if (targets.length === 0) {
+    throw new CliError(
+      "runtime_not_found",
+      "The CLI could not find a supported local ChatGPT, Codex, or Claude skill folder on this Mac."
+    );
+  }
+  return targets;
+};
+
+// src/commands.ts
+var output = (context, message) => {
+  (context.stdout ?? process.stdout).write(`${message}
+`);
+};
+var validatedSkillName = (value) => {
+  const result = SkillNameSchema.safeParse(value);
+  if (!result.success) {
+    throw new CliError("invalid_skill_name", "Use the exact lowercase skill name from the catalog.");
+  }
+  return result.data;
+};
+var findSkill = (manifest, name) => {
+  const skill = manifest.skills.find((candidate) => candidate.name === name);
+  if (skill === void 0) {
+    throw new CliError("skill_not_found", `The private registry does not contain ${name}.`);
+  }
+  return skill;
+};
+var ensurePrivateCache = async (home) => {
+  const cache = localPaths(home).cache;
+  await mkdir4(cache, { recursive: true, mode: 448 });
+  const cacheStat = await lstat6(cache);
+  if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) {
+    throw new CliError("unsafe_cache", "The Yeka Skills cache is not a real directory.");
+  }
+  return cache;
+};
+var downloadAndInstall = async (client, token, skill, targets, options, home) => {
+  const cache = await ensurePrivateCache(home);
+  const downloadRoot = await mkdtemp2(path7.join(cache, "download-"));
+  await chmod2(downloadRoot, 448);
+  const archivePath = path7.join(downloadRoot, `${skill.name}.tgz`);
+  try {
+    await client.downloadArtifact(skill, token, archivePath);
+    return await installSkillFromArchive({
+      skill,
+      archivePath,
+      targets,
+      ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun },
+      home
+    });
+  } finally {
+    await rm3(downloadRoot, { recursive: true, force: true });
+  }
+};
+var actionMessage = (skillName, action, dryRun) => {
+  switch (action.action) {
+    case "install":
+      return dryRun ? `Would install ${skillName} for ${action.runtime} at ${action.installedPath}.` : `Installed ${skillName} for ${action.runtime} at ${action.installedPath}.`;
+    case "update":
+      return dryRun ? `Would update ${skillName} for ${action.runtime} at ${action.installedPath}.` : `Updated ${skillName} for ${action.runtime} at ${action.installedPath}.`;
+    case "replace-unmanaged":
+      return dryRun ? `Would back up the existing ${action.runtime} copy and install ${skillName}.` : `Backed up the existing ${action.runtime} copy and installed ${skillName}.`;
+    case "unchanged":
+      return `${skillName} is current for ${action.runtime}.`;
+  }
+};
+var printActions = (context, skillName, actions, dryRun) => {
+  for (const action of actions) {
+    output(context, actionMessage(skillName, action, dryRun));
+    if (!dryRun && action.backupPath !== void 0) {
+      output(context, `Backup: ${action.backupPath}`);
+    }
+  }
+};
+var addCommand = async (skillNameInput, options, context = {}) => {
+  const skillName = validatedSkillName(skillNameInput);
+  const home = path7.resolve(context.home ?? os6.homedir());
+  const client = context.client ?? new RegistryClient();
+  const actions = await withRegistrySession(async (token) => {
+    const manifest = await client.getManifest(token);
+    const skill = findSkill(manifest, skillName);
+    const targets = await resolveInstallTargets(skill, home);
+    return downloadAndInstall(client, token, skill, targets, options, home);
+  });
+  printActions(context, skillName, actions, options.dryRun === true);
+};
+var receiptGroups = (receipts) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    const group = groups.get(receipt.skillName) ?? [];
+    group.push(receipt);
+    groups.set(receipt.skillName, group);
+  }
+  return groups;
+};
+var statusLabel = (status) => {
+  switch (status.kind) {
+    case "current":
+      return "current";
+    case "update-available":
+      return "update available";
+    case "modified":
+      return "local changes";
+    case "missing":
+      return "missing";
+    case "unavailable":
+      return "not in registry";
+  }
+};
+var listCommand = async (context = {}) => {
+  const home = path7.resolve(context.home ?? os6.homedir());
+  const receipts = await listReceipts(home);
+  if (receipts.length === 0) {
+    output(context, "No managed Yeka skills are installed.");
+    return;
+  }
+  for (const receipt of receipts) {
+    output(context, `${receipt.skillName}	${receipt.runtime}	${receipt.installedPath}`);
+  }
+};
+var statusCommand = async (context = {}) => {
+  const home = path7.resolve(context.home ?? os6.homedir());
+  const receipts = await listReceipts(home);
+  if (receipts.length === 0) {
+    output(context, "No managed Yeka skills are installed.");
+    return;
+  }
+  const client = context.client ?? new RegistryClient();
+  const statuses = await withRegistrySession(async (token) => {
+    const manifest = await client.getManifest(token);
+    const remoteByName = new Map(manifest.skills.map((skill) => [skill.name, skill]));
+    return Promise.all(
+      receipts.map((receipt) => inspectLocalStatus(receipt, remoteByName.get(receipt.skillName), home))
+    );
+  });
+  for (const status of statuses) {
+    output(
+      context,
+      `${status.receipt.skillName}	${status.receipt.runtime}	${statusLabel(status)}`
+    );
+  }
+};
+var assertUpdatableStatuses = (skillName, statuses) => {
+  const modified = statuses.find((status) => status.kind === "modified");
+  if (modified !== void 0) {
+    throw new CliError(
+      "local_changes",
+      `${skillName} has local changes for ${modified.receipt.runtime}. It was not changed.`
+    );
+  }
+  if (statuses.some((status) => status.kind === "unavailable")) {
+    throw new CliError("skill_unavailable", `${skillName} is no longer available in the private registry.`);
+  }
+};
+var updateCommand = async (skillNameInput, options, context = {}) => {
+  const selectedName = skillNameInput === void 0 ? void 0 : validatedSkillName(skillNameInput);
+  const home = path7.resolve(context.home ?? os6.homedir());
+  const allReceipts = await listReceipts(home);
+  const groups = receiptGroups(allReceipts);
+  if (selectedName !== void 0 && !groups.has(selectedName)) {
+    throw new CliError("not_installed", `${selectedName} is not a managed installation.`);
+  }
+  if (groups.size === 0) {
+    output(context, "No managed Yeka skills are installed.");
+    return;
+  }
+  const client = context.client ?? new RegistryClient();
+  const results = await withRegistrySession(async (token) => {
+    const manifest = await client.getManifest(token);
+    const remoteByName = new Map(manifest.skills.map((skill) => [skill.name, skill]));
+    const selectedGroups = [...groups.entries()].filter(([name]) => selectedName === void 0 || name === selectedName);
+    const prepared = [];
+    for (const [name, receipts] of selectedGroups) {
+      const remote = remoteByName.get(name);
+      const statuses = await Promise.all(
+        receipts.map((receipt) => inspectLocalStatus(receipt, remote, home))
+      );
+      assertUpdatableStatuses(name, statuses);
+      if (remote === void 0) {
+        throw new CliError("skill_unavailable", `${name} is no longer available in the private registry.`);
+      }
+      prepared.push({ name, receipts, skill: remote, statuses });
+    }
+    const updated = [];
+    for (const item of prepared) {
+      if (item.statuses.every((status) => status.kind === "current")) {
+        updated.push({
+          name: item.name,
+          actions: item.receipts.map((receipt) => ({
+            action: "unchanged",
+            runtime: receipt.runtime,
+            targetRoot: receipt.targetRoot,
+            installedPath: receipt.installedPath
+          }))
+        });
+        continue;
+      }
+      const targets = targetsFromReceipts(item.receipts, item.name, home);
+      updated.push({
+        name: item.name,
+        actions: await downloadAndInstall(client, token, item.skill, targets, options, home)
+      });
+    }
+    return updated;
+  });
+  for (const result of results) {
+    printActions(context, result.name, result.actions, options.dryRun === true);
+  }
+};
+var loginCommand = async (context = {}) => {
+  await deleteSession();
+  await login();
+  output(context, "Yeka Skills is ready.");
+};
+var logoutCommand = async (context = {}) => {
+  const removed = await deleteSession();
+  output(context, removed ? "The Yeka Skills session was removed." : "There was no saved Yeka Skills session.");
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("yeka-skills").description("Install and update private Gemography agent skills").version("0.1.0").showHelpAfterError();
+program.command("add").description("Install one private skill").argument("<skill>", "exact skill name").option("--dry-run", "verify and show changes without installation").action(async (skill, options) => addCommand(skill, options));
+program.command("list").description("List managed local skills without network access").action(async () => listCommand());
+program.command("status").description("Check local skills and available updates").action(async () => statusCommand());
+program.command("update").description("Update one managed skill or all managed skills").argument("[skill]", "exact skill name").option("--dry-run", "verify and show changes without installation").action(
+  async (skill, options) => updateCommand(skill, options)
+);
+program.command("login").description("Start a new private registry session").action(async () => loginCommand());
+program.command("logout").description("Remove the saved private registry session").action(async () => logoutCommand());
+var main = async () => {
+  if (process.platform !== "darwin") {
+    throw new CliError("unsupported_platform", "Yeka Skills currently supports macOS only.");
+  }
+  await program.parseAsync(process.argv);
+};
+main().catch((error) => {
+  if (error instanceof CliError) {
+    process.stderr.write(`Error: ${error.message}
+`);
+    process.exitCode = error.exitCode;
+    return;
+  }
+  process.stderr.write("Error: Yeka Skills stopped because of an unexpected error.\n");
+  if (process.env.YEKA_SKILLS_DEBUG === "1" && error instanceof Error) {
+    process.stderr.write(`${error.stack ?? error.message}
+`);
+  }
+  process.exitCode = 1;
+});