@hasna/skills 0.1.44 → 0.1.45

package/dist/index.js

@@ -18776,7 +18776,7 @@ import { dirname as dirname4, relative as relative3 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.44",
+  version: "0.1.45",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -18787,6 +18787,10 @@ var package_default = {
     ".": {
       import: "./dist/index.js",
       types: "./dist/index.d.ts"
+    },
+    "./storage": {
+      import: "./dist/storage.js",
+      types: "./dist/storage.d.ts"
     }
   },
   files: [
@@ -18807,7 +18811,7 @@ var package_default = {
   types: "./dist/index.d.ts",
   scripts: {
     clean: "rm -rf bin/ dist/",
-    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts ./src/storage.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
     test: "bun test",
     dev: "bun run ./src/cli/index.tsx",
     "dev:watch": "bun --watch run ./src/cli/index.tsx",
@@ -18837,9 +18841,11 @@ var package_default = {
   devDependencies: {
     "@types/bun": "latest",
     "@types/react": "^18.2.0",
+    "react-devtools-core": "^7.0.1",
     typescript: "^5"
   },
   dependencies: {
+    "@hasna/events": "^0.1.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -19314,6 +19320,46 @@ var toolContracts = [
     inputSchema: objectSchema(),
     outputSchema: objectSchema({}, [], "Setup summary.", true)
   },
+  {
+    name: "storage_status",
+    title: "Storage Status",
+    description: "Show local-first storage paths and optional repo-owned Postgres/S3 readiness.",
+    params: ["directory?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ directory: stringSchema("Project directory.") }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      local: objectSchema({}, [], "Local storage paths.", true),
+      remote: objectSchema({}, [], "Remote storage readiness.", true)
+    }, ["package", "mode", "local", "remote"])
+  },
+  {
+    name: "storage_sync_plan",
+    title: "Storage Sync Plan",
+    description: "Plan .skills snapshot sync for optional Postgres/S3 storage without network access.",
+    params: ["directory?", "includeSchemaSql?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({
+      directory: stringSchema("Project directory."),
+      includeSchemaSql: { type: "boolean", default: false }
+    }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      noNetwork: { type: "boolean", const: true },
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      databaseConfigured: { type: "boolean" },
+      s3Configured: { type: "boolean" },
+      snapshotFileCount: { type: "number" },
+      s3ObjectCount: { type: "number" },
+      env: objectSchema({}, [], "Storage env var names.", true),
+      schemaSql: stringSchema("Optional Postgres schema SQL.")
+    }, ["package", "noNetwork", "mode", "databaseConfigured", "s3Configured"])
+  },
   {
     name: "schedule_skill",
     title: "Schedule Skill",
@@ -19666,6 +19712,553 @@ function saveFeedback(input) {
   }
   return { saved: true, category, path: getFeedbackDbPath() };
 }
+// src/lib/native-storage.ts
+import { createHash as createHash2, createHmac } from "crypto";
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync5,
+  statSync as statSync4,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { dirname as dirname6, join as join12, normalize as normalize3, relative as relative4, sep } from "path";
+var SKILLS_STORAGE_TABLES = [
+  "skills_sync_records",
+  "skills_sync_cursors"
+];
+var STORAGE_TABLES = SKILLS_STORAGE_TABLES;
+var SKILLS_NATIVE_STORAGE_ENV = {
+  mode: "HASNA_SKILLS_STORAGE_MODE",
+  databaseUrl: "HASNA_SKILLS_DATABASE_URL",
+  databaseSsl: "HASNA_SKILLS_DATABASE_SSL",
+  databaseSchema: "HASNA_SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "HASNA_SKILLS_S3_BUCKET",
+  s3Prefix: "HASNA_SKILLS_S3_PREFIX",
+  awsRegion: "HASNA_SKILLS_AWS_REGION",
+  s3Endpoint: "HASNA_SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "HASNA_SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "HASNA_SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "HASNA_SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "HASNA_SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "HASNA_SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "HASNA_SKILLS_SYNC_DRY_RUN"
+};
+var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
+  mode: "SKILLS_STORAGE_MODE",
+  databaseUrl: "SKILLS_DATABASE_URL",
+  databaseSsl: "SKILLS_DATABASE_SSL",
+  databaseSchema: "SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "SKILLS_S3_BUCKET",
+  s3Prefix: "SKILLS_S3_PREFIX",
+  awsRegion: "SKILLS_AWS_REGION",
+  s3Endpoint: "SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "SKILLS_SYNC_DRY_RUN"
+};
+var SKILLS_STORAGE_ENV = SKILLS_NATIVE_STORAGE_ENV;
+var SKILLS_STORAGE_FALLBACK_ENV = SKILLS_NATIVE_STORAGE_FALLBACK_ENV;
+function resolveSkillsNativeStorageConfig(env = process.env) {
+  const mode = getSkillsStorageMode(env);
+  return {
+    mode,
+    databaseUrl: getSkillsStorageDatabaseUrl(env),
+    databaseSsl: parseBoolean(readStorageEnv(env, "databaseSsl").value),
+    databaseSchema: readStorageEnv(env, "databaseSchema").value,
+    s3Bucket: readStorageEnv(env, "s3Bucket").value,
+    s3Prefix: readStorageEnv(env, "s3Prefix").value,
+    awsRegion: readStorageEnv(env, "awsRegion").value ?? "us-east-1",
+    s3Endpoint: readStorageEnv(env, "s3Endpoint").value,
+    s3ForcePathStyle: parseBoolean(readStorageEnv(env, "s3ForcePathStyle").value) ?? false,
+    syncBatchSize: parsePositiveInteger(readStorageEnv(env, "syncBatchSize").value) ?? 500,
+    dryRun: parseBoolean(readStorageEnv(env, "dryRun").value) ?? true
+  };
+}
+function resolveStorageConfig(env = process.env) {
+  return resolveSkillsNativeStorageConfig(env);
+}
+function getSkillsStorageMode(env = process.env) {
+  return parseMode(readStorageEnv(env, "mode").value);
+}
+function getStorageMode(env = process.env) {
+  return getSkillsStorageMode(env);
+}
+function getSkillsStorageDatabaseEnv(env = process.env) {
+  return readStorageEnv(env, "databaseUrl").name;
+}
+function getStorageDatabaseEnv(env = process.env) {
+  return getSkillsStorageDatabaseEnv(env);
+}
+function getSkillsStorageDatabaseUrl(env = process.env) {
+  return readStorageEnv(env, "databaseUrl").value;
+}
+function getStorageDatabaseUrl(env = process.env) {
+  return getSkillsStorageDatabaseUrl(env);
+}
+function getSkillsNativeStorageStatus(options = {}) {
+  const env = options.env ?? process.env;
+  const config2 = resolveSkillsNativeStorageConfig(env);
+  const modeEnv = readStorageEnv(env, "mode");
+  const databaseEnv = readStorageEnv(env, "databaseUrl");
+  const s3BucketEnv = readStorageEnv(env, "s3Bucket");
+  const targetDir = options.targetDir ?? process.cwd();
+  return {
+    package: "open-skills",
+    mode: config2.mode,
+    tables: [...SKILLS_STORAGE_TABLES],
+    env: {
+      mode: SKILLS_NATIVE_STORAGE_ENV.mode,
+      databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
+    },
+    local: {
+      dataDir: getDataDir(),
+      projectStateDir: getProjectStateDir(targetDir),
+      feedbackDbPath: join12(getDataDir(), "skills.db")
+    },
+    remote: {
+      databaseConfigured: Boolean(config2.databaseUrl),
+      s3Configured: Boolean(config2.s3Bucket),
+      databaseEnv: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3BucketEnv: SKILLS_NATIVE_STORAGE_ENV.s3Bucket,
+      activeModeEnv: modeEnv.name,
+      activeDatabaseEnv: databaseEnv.name,
+      activeS3BucketEnv: s3BucketEnv.name,
+      region: config2.awsRegion ?? "us-east-1",
+      dryRun: config2.dryRun
+    }
+  };
+}
+function getSkillsStorageStatus(options = {}) {
+  return getSkillsNativeStorageStatus(options);
+}
+function getStorageStatus(options = {}) {
+  return getSkillsNativeStorageStatus(options);
+}
+function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
+  const projectStateDir = getProjectStateDir(targetDir);
+  const files = [];
+  if (existsSync12(projectStateDir)) {
+    for (const filePath of walkFiles2(projectStateDir)) {
+      const bytes = readFileSync11(filePath);
+      const relativePath = toPosix(relative4(targetDir, filePath));
+      files.push({
+        path: relativePath,
+        sizeBytes: bytes.byteLength,
+        sha256: createHash2("sha256").update(bytes).digest("hex"),
+        ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
+      });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    files: files.sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options = {}) {
+  let written = 0;
+  let skipped = 0;
+  for (const file2 of snapshot.files) {
+    if (!file2.contentBase64) {
+      skipped += 1;
+      continue;
+    }
+    const absolutePath = resolveSnapshotPath(targetDir, file2.path);
+    if (existsSync12(absolutePath) && !options.overwrite) {
+      skipped += 1;
+      continue;
+    }
+    const bytes = Buffer.from(file2.contentBase64, "base64");
+    const hash2 = createHash2("sha256").update(bytes).digest("hex");
+    if (hash2 !== file2.sha256) {
+      throw new Error(`Snapshot file checksum mismatch: ${file2.path}`);
+    }
+    mkdirSync9(dirname6(absolutePath), { recursive: true });
+    writeFileSync8(absolutePath, bytes);
+    written += 1;
+  }
+  return { written, skipped };
+}
+var skillsPostgresSyncSchemaSql = `
+CREATE TABLE IF NOT EXISTS skills_sync_records (
+  scope TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  id TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  deleted_at TIMESTAMPTZ,
+  source TEXT,
+  payload JSONB NOT NULL,
+  PRIMARY KEY (scope, kind, id)
+);
+
+CREATE INDEX IF NOT EXISTS skills_sync_records_updated_at_idx
+  ON skills_sync_records (updated_at);
+
+CREATE TABLE IF NOT EXISTS skills_sync_cursors (
+  scope TEXT NOT NULL,
+  cursor_name TEXT NOT NULL,
+  value TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (scope, cursor_name)
+);
+`.trim();
+
+class SkillsPostgresSyncStore {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async ensureSchema() {
+    await this.client.query(skillsPostgresSyncSchemaSql);
+  }
+  async upsertRecords(records) {
+    let count = 0;
+    for (const record2 of records) {
+      await this.client.query([
+        "INSERT INTO skills_sync_records",
+        "(scope, kind, id, updated_at, deleted_at, source, payload)",
+        "VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)",
+        "ON CONFLICT (scope, kind, id) DO UPDATE SET",
+        "updated_at = EXCLUDED.updated_at,",
+        "deleted_at = EXCLUDED.deleted_at,",
+        "source = EXCLUDED.source,",
+        "payload = EXCLUDED.payload"
+      ].join(" "), [
+        record2.scope,
+        record2.kind,
+        record2.id,
+        record2.updatedAt,
+        record2.deletedAt ?? null,
+        record2.source ?? null,
+        JSON.stringify(record2.payload)
+      ]);
+      count += 1;
+    }
+    return count;
+  }
+  async pullUpdatedSince(params) {
+    const limit = params.limit ?? 500;
+    const result = await this.client.query([
+      "SELECT scope, kind, id, updated_at, deleted_at, source, payload",
+      "FROM skills_sync_records",
+      "WHERE scope = $1 AND updated_at > $2",
+      "ORDER BY updated_at ASC",
+      "LIMIT $3"
+    ].join(" "), [params.scope, params.since ?? "1970-01-01T00:00:00.000Z", limit]);
+    return result.rows.map((row) => ({
+      scope: row.scope,
+      kind: row.kind,
+      id: row.id,
+      updatedAt: toIsoString(row.updated_at),
+      deletedAt: row.deleted_at ? toIsoString(row.deleted_at) : null,
+      source: row.source,
+      payload: typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload
+    }));
+  }
+  async getCursor(scope, cursorName) {
+    const result = await this.client.query("SELECT value FROM skills_sync_cursors WHERE scope = $1 AND cursor_name = $2", [scope, cursorName]);
+    return result.rows[0]?.value ?? null;
+  }
+  async setCursor(scope, cursorName, value) {
+    await this.client.query([
+      "INSERT INTO skills_sync_cursors (scope, cursor_name, value, updated_at)",
+      "VALUES ($1, $2, $3, now())",
+      "ON CONFLICT (scope, cursor_name) DO UPDATE SET",
+      "value = EXCLUDED.value, updated_at = EXCLUDED.updated_at"
+    ].join(" "), [scope, cursorName, value]);
+  }
+}
+function createSkillsPostgresSyncStore(client) {
+  return new SkillsPostgresSyncStore(client);
+}
+function createSkillsSnapshotSyncRecord(snapshot, options = {}) {
+  return {
+    scope: options.scope ?? "default",
+    kind: "local-snapshot",
+    id: options.id ?? "project-state",
+    updatedAt: snapshot.exportedAt,
+    source: options.source ?? "open-skills",
+    payload: snapshot
+  };
+}
+
+class SkillsS3ObjectStore {
+  options;
+  fetchImpl;
+  region;
+  prefix;
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.region = options.region ?? "us-east-1";
+    this.prefix = normalizeS3Prefix(options.prefix);
+  }
+  objectKey(path) {
+    const cleaned = toPosix(path).replace(/^\.?\//, "").replace(/^\/+/, "");
+    return [this.prefix, cleaned].filter(Boolean).join("/");
+  }
+  objectUrl(key) {
+    return buildSkillsS3ObjectUrl({
+      bucket: this.options.bucket,
+      key,
+      region: this.region,
+      endpoint: this.options.endpoint,
+      forcePathStyle: this.options.forcePathStyle
+    });
+  }
+  async putObject(params) {
+    const key = this.objectKey(params.key);
+    const body = typeof params.body === "string" ? new TextEncoder().encode(params.body) : params.body;
+    const url2 = this.objectUrl(key);
+    const headers = {
+      "content-type": params.contentType ?? "application/octet-stream",
+      "x-amz-content-sha256": sha256Hex(body)
+    };
+    const signed = signSkillsAwsV4Request({
+      method: "PUT",
+      url: url2,
+      region: this.region,
+      service: "s3",
+      headers,
+      body,
+      credentials: this.options.credentials
+    });
+    const response = await this.fetchImpl(url2, {
+      method: "PUT",
+      headers: signed.headers,
+      body: toArrayBuffer(body)
+    });
+    if (!response.ok) {
+      throw new Error(`S3 put failed for ${key}: ${response.status} ${response.statusText}`.trim());
+    }
+    return {
+      key,
+      url: url2,
+      etag: response.headers.get("etag"),
+      sizeBytes: body.byteLength
+    };
+  }
+  async getObject(key) {
+    const objectKey = this.objectKey(key);
+    const url2 = this.objectUrl(objectKey);
+    const signed = signSkillsAwsV4Request({
+      method: "GET",
+      url: url2,
+      region: this.region,
+      service: "s3",
+      headers: { "x-amz-content-sha256": sha256Hex(new Uint8Array) },
+      credentials: this.options.credentials
+    });
+    const response = await this.fetchImpl(url2, {
+      method: "GET",
+      headers: signed.headers
+    });
+    if (!response.ok) {
+      throw new Error(`S3 get failed for ${objectKey}: ${response.status} ${response.statusText}`.trim());
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+}
+function createSkillsS3ObjectStore(options) {
+  return new SkillsS3ObjectStore(options);
+}
+function planSkillsS3SnapshotUpload(snapshot, options = {}) {
+  const prefix = normalizeS3Prefix(options.prefix);
+  return snapshot.files.map((file2) => ({
+    path: file2.path,
+    key: [prefix, file2.path.replace(/^\.?\//, "")].filter(Boolean).join("/"),
+    sizeBytes: file2.sizeBytes,
+    sha256: file2.sha256
+  }));
+}
+async function uploadSkillsSnapshotFilesToS3(snapshot, store) {
+  const uploaded = [];
+  for (const file2 of snapshot.files) {
+    if (!file2.contentBase64)
+      continue;
+    uploaded.push(await store.putObject({
+      key: file2.path,
+      body: Buffer.from(file2.contentBase64, "base64"),
+      contentType: contentTypeForPath(file2.path)
+    }));
+  }
+  return uploaded;
+}
+function signSkillsAwsV4Request(options) {
+  const now = options.now ?? new Date;
+  const amzDate = toAmzDate(now);
+  const dateStamp = amzDate.slice(0, 8);
+  const url2 = new URL(options.url);
+  const bodyBytes = typeof options.body === "string" ? new TextEncoder().encode(options.body) : options.body ?? new Uint8Array;
+  const payloadHash = sha256Hex(bodyBytes);
+  const headers = normalizeHeaders({
+    ...options.headers ?? {},
+    host: url2.host,
+    "x-amz-date": amzDate,
+    "x-amz-content-sha256": options.headers?.["x-amz-content-sha256"] ?? payloadHash,
+    ...options.credentials.sessionToken ? { "x-amz-security-token": options.credentials.sessionToken } : {}
+  });
+  const signedHeaderNames = Object.keys(headers).sort();
+  const canonicalHeaders = signedHeaderNames.map((name) => `${name}:${headers[name]}
+`).join("");
+  const canonicalQuery = canonicalizeQuery(url2.searchParams);
+  const canonicalRequest = [
+    options.method.toUpperCase(),
+    encodeUriPath(url2.pathname),
+    canonicalQuery,
+    canonicalHeaders,
+    signedHeaderNames.join(";"),
+    headers["x-amz-content-sha256"]
+  ].join(`
+`);
+  const credentialScope = `${dateStamp}/${options.region}/${options.service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    credentialScope,
+    sha256Hex(canonicalRequest)
+  ].join(`
+`);
+  const signingKey = getAwsSigningKey(options.credentials.secretAccessKey, dateStamp, options.region, options.service);
+  const signature = createHmac("sha256", signingKey).update(stringToSign).digest("hex");
+  headers.authorization = [
+    `AWS4-HMAC-SHA256 Credential=${options.credentials.accessKeyId}/${credentialScope}`,
+    `SignedHeaders=${signedHeaderNames.join(";")}`,
+    `Signature=${signature}`
+  ].join(", ");
+  return { headers, canonicalRequest, stringToSign };
+}
+function buildSkillsS3ObjectUrl(params) {
+  const region = params.region ?? "us-east-1";
+  const key = params.key.split("/").map(encodeURIComponent).join("/");
+  if (params.endpoint) {
+    const endpoint = params.endpoint.replace(/\/+$/, "");
+    return params.forcePathStyle ? `${endpoint}/${encodeURIComponent(params.bucket)}/${key}` : `${endpoint}/${key}`;
+  }
+  return params.forcePathStyle ? `https://s3.${region}.amazonaws.com/${encodeURIComponent(params.bucket)}/${key}` : `https://${params.bucket}.s3.${region}.amazonaws.com/${key}`;
+}
+function parseMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "remote" || normalized === "hybrid")
+    return normalized;
+  return "local";
+}
+function readStorageEnv(env, key) {
+  const primaryName = SKILLS_NATIVE_STORAGE_ENV[key];
+  const primaryValue = cleanOptional(env[primaryName]);
+  if (primaryValue !== undefined)
+    return { name: primaryName, value: primaryValue };
+  const fallbackName = SKILLS_NATIVE_STORAGE_FALLBACK_ENV[key];
+  const fallbackValue = cleanOptional(env[fallbackName]);
+  if (fallbackValue !== undefined)
+    return { name: fallbackName, value: fallbackValue };
+  return { name: primaryName };
+}
+function cleanOptional(value) {
+  const cleaned = value?.trim();
+  return cleaned ? cleaned : undefined;
+}
+function parseBoolean(value) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized))
+    return true;
+  if (["0", "false", "no", "off"].includes(normalized))
+    return false;
+  return;
+}
+function parsePositiveInteger(value) {
+  if (!value)
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function walkFiles2(dir) {
+  const files = [];
+  for (const entry of readdirSync5(dir)) {
+    const full = join12(dir, entry);
+    const stats = statSync4(full);
+    if (stats.isDirectory())
+      files.push(...walkFiles2(full));
+    else
+      files.push(full);
+  }
+  return files;
+}
+function resolveSnapshotPath(targetDir, snapshotPath) {
+  const normalizedPath = normalize3(snapshotPath);
+  if (normalizedPath.startsWith("..") || normalizedPath.includes(`${sep}..${sep}`) || normalizedPath.startsWith(sep)) {
+    throw new Error(`Unsafe snapshot path: ${snapshotPath}`);
+  }
+  if (!toPosix(normalizedPath).startsWith(".skills/")) {
+    throw new Error(`Snapshot path must stay inside .skills: ${snapshotPath}`);
+  }
+  return join12(targetDir, normalizedPath);
+}
+function normalizeS3Prefix(prefix) {
+  return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
+}
+function toPosix(path) {
+  return path.split(/[\\/]+/).join("/");
+}
+function toIsoString(value) {
+  const date5 = new Date(value);
+  return Number.isNaN(date5.getTime()) ? value : date5.toISOString();
+}
+function sha256Hex(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function normalizeHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    result[key.toLowerCase()] = String(value).trim().replace(/\s+/g, " ");
+  }
+  return result;
+}
+function canonicalizeQuery(params) {
+  return [...params.entries()].sort(([aKey, aValue], [bKey, bValue]) => aKey.localeCompare(bKey) || aValue.localeCompare(bValue)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+function encodeUriPath(pathname) {
+  return pathname.split("/").map((segment) => encodeURIComponent(decodeURIComponent(segment)).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}
+function toAmzDate(date5) {
+  return date5.toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+function getAwsSigningKey(secret, dateStamp, region, service) {
+  const kDate = createHmac("sha256", `AWS4${secret}`).update(dateStamp).digest();
+  const kRegion = createHmac("sha256", kDate).update(region).digest();
+  const kService = createHmac("sha256", kRegion).update(service).digest();
+  return createHmac("sha256", kService).update("aws4_request").digest();
+}
+function contentTypeForPath(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".json"))
+    return "application/json";
+  if (lower.endsWith(".log") || lower.endsWith(".txt") || lower.endsWith(".ndjson"))
+    return "text/plain";
+  if (lower.endsWith(".md"))
+    return "text/markdown";
+  if (lower.endsWith(".png"))
+    return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+    return "image/jpeg";
+  if (lower.endsWith(".webp"))
+    return "image/webp";
+  if (lower.endsWith(".pdf"))
+    return "application/pdf";
+  return "application/octet-stream";
+}
+function toArrayBuffer(bytes) {
+  const buffer = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(buffer).set(bytes);
+  return buffer;
+}
 export {
   writeRunLogs,
   writeRegistrySyncArtifact,
@@ -19675,11 +20268,14 @@ export {
   validatePortableSkillDirectory,
   validateCron,
   validateBlogArticleRunOptions,
+  uploadSkillsSnapshotFilesToS3,
   updateSkillRun,
   unpinSkill,
   unpinProjectSkill,
   summarizeMcpToolContract,
+  skillsPostgresSyncSchemaSql,
   skillExists,
+  signSkillsAwsV4Request,
   setSkillDisabled,
   setScheduleEnabled,
   searchSkills,
@@ -19690,6 +20286,8 @@ export {
   sanitizePublicDiscoveryText,
   runSkill,
   runPortableSkill,
+  resolveStorageConfig,
+  resolveSkillsNativeStorageConfig,
   resolveSkillAlias,
   removeSkillForAgent,
   removeSkill,
@@ -19701,6 +20299,7 @@ export {
   publicDiscoveryDocumentation,
   publicDiscoveryDependencies,
   portPortableSkill,
+  planSkillsS3SnapshotUpload,
   pinSkill,
   pinProjectSkill,
   parseSkillFrontmatter,
@@ -19729,6 +20328,16 @@ export {
   installSkillManifest,
   installSkillForAgent,
   installSkill,
+  importSkillsLocalSnapshot,
+  getStorageStatus,
+  getStorageMode,
+  getStorageDatabaseUrl,
+  getStorageDatabaseEnv,
+  getSkillsStorageStatus,
+  getSkillsStorageMode,
+  getSkillsStorageDatabaseUrl,
+  getSkillsStorageDatabaseEnv,
+  getSkillsNativeStorageStatus,
   getSkillsByTag,
   getSkillsByCategory,
   getSkillRunCostCents,
@@ -19770,10 +20379,14 @@ export {
   findSkillRun,
   findSimilarSkills,
   findPortableSkill,
+  exportSkillsLocalSnapshot,
   ensureProjectConfig,
   enableSkill,
   disableSkill,
   describeMcpToolContracts,
+  createSkillsSnapshotSyncRecord,
+  createSkillsS3ObjectStore,
+  createSkillsPostgresSyncStore,
   createSkillRun,
   createSkillMcpMetadata,
   createRemoteSkillsClient,
@@ -19782,11 +20395,20 @@ export {
   createLocalSkillManifest,
   completeSkillRun,
   clearRegistryCache,
+  buildSkillsS3ObjectUrl,
   buildSkillsApiUrl,
   appendRunEvent,
   addSchedule,
+  SkillsS3ObjectStore,
+  SkillsPostgresSyncStore,
+  STORAGE_TABLES,
   SKILL_ALIASES,
+  SKILLS_STORAGE_TABLES,
+  SKILLS_STORAGE_FALLBACK_ENV,
+  SKILLS_STORAGE_ENV,
   SKILLS_PROJECT_DIR,
+  SKILLS_NATIVE_STORAGE_FALLBACK_ENV,
+  SKILLS_NATIVE_STORAGE_ENV,
   SKILLS_CLI_MCP_PARITY,
   SKILLS,
   RemoteSkillsClient,