@hasna/skills 0.1.70 → 0.1.72

package/bin/worker.js

@@ -22940,7 +22940,6 @@ var init_dist_es9 = __esm(() => {
 
 // src/server/worker.ts
 import { randomUUID as randomUUID4 } from "crypto";
-
 // src/lib/skill-bundle.ts
 var ANY_SEGMENT_EXCLUDES = new Set([
   ".git",
@@ -32876,13 +32875,12 @@ var DEFAULT_RUN_QUOTA = {
 };
 
 // src/server/database-url.ts
-import { isAbsolute, join as join3 } from "path";
+import { isAbsolute, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/config.ts
-import { existsSync, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 
 // src/lib/retired-settings.ts
 var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
@@ -32919,59 +32917,167 @@ function assertNoRetiredModeEnvVars(env, options) {
   throw new RetiredSettingError(names[0], `${names.join(", ")} ${names.length === 1 ? "is" : "are"} no longer read. ` + "Deployment modes were removed: where a server keeps its data is decided by the " + `database it is given, not by a declared label. Set ${options.replacement} to a ` + "postgres:// URL to use PostgreSQL, or leave it unset for the on-box SQLite database. " + `Then unset ${names.join(" and ")}. ` + "Refused rather than ignored, because a discarded setting looks exactly like a " + "working one until something needs the data.");
 }
 
+// src/lib/app-home.ts
+import { existsSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, resolve } from "path";
+
+// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function assertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function envOf(options) {
+  return options.env ?? process.env;
+}
+function envValue(options, kind) {
+  const value = envOf(options)[KIND_ENV[kind]];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isMacOS(platform) {
+  return platform === "darwin";
+}
+function baseDir(kind, options) {
+  const override = envValue(options, kind);
+  if (override)
+    return override;
+  const home = options.home ?? homedir2();
+  const platform = options.platform ?? process.platform;
+  if (isMacOS(platform)) {
+    switch (kind) {
+      case "config":
+      case "data":
+        return join2(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return join2(home, "Library", "Caches", "Hasna");
+      case "state":
+        return join2(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return join2(home, ".config", "hasna");
+    case "data":
+      return join2(home, ".local", "share", "hasna");
+    case "state":
+      return join2(home, ".local", "state", "hasna");
+    case "cache":
+      return join2(home, ".cache", "hasna");
+  }
+}
+function resolvePath(kind, options) {
+  assertApp(options.app);
+  const appSegment = options.internal === true ? join2("internal", options.app) : options.app;
+  return join2(baseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return resolvePath("data", options);
+}
+
+// src/lib/app-home.ts
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+var HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME";
+var SKILLS_HOME_ENV = "SKILLS_HOME";
+var DEFAULT_SQLITE_FILENAME = "server.db";
+var GLOBAL_CONFIG_FILENAME = "config.json";
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir3() || "/tmp";
+}
+function legacyDataRoot() {
+  return join3(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome()) {
+  return dataDir({ app: "skills", home });
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join3(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join3(resolved, GLOBAL_CONFIG_FILENAME));
+}
+function exactDataRoot() {
+  for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
+    const dir = process.env[key]?.trim();
+    if (dir)
+      return resolve(dir);
+  }
+  return;
+}
+function hasExactOverride(env = process.env) {
+  return Boolean(env[DATA_DIR_ENV]?.trim()) || Boolean(env[HASNA_SKILLS_HOME_ENV]?.trim()) || Boolean(env[SKILLS_HOME_ENV]?.trim());
+}
+function hasOperatorOverride(env = process.env) {
+  return hasExactOverride(env) || Boolean(env.HASNA_DATA_HOME?.trim());
+}
+function getDataRoot() {
+  const exact = exactDataRoot();
+  if (exact)
+    return exact;
+  const resolved = resolverDataRoot();
+  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
+}
 // src/lib/config.ts
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync(sourceDir))
+  if (!existsSync2(sourceDir))
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join2(sourceDir, entry);
-    const targetPath = join2(targetDir, entry);
+    const sourcePath = join4(sourceDir, entry);
+    const targetPath = join4(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync(targetPath))
+      if (!existsSync2(targetPath))
         copyFileSync(sourcePath, targetPath);
     } catch {}
   }
 }
-var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
 function getDataDir() {
-  const override = process.env[DATA_DIR_ENV];
-  if (override) {
-    try {
-      mkdirSync(override, { recursive: true });
-    } catch {}
-    return override;
-  }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
-  const newDir = join2(home, ".hasna", "skills");
-  const oldDir = join2(home, ".skills");
-  const oldConfigFile = join2(home, ".skillsrc");
-  mkdirSync(newDir, { recursive: true });
+  const root3 = getDataRoot();
+  try {
+    mkdirSync(root3, { recursive: true });
+  } catch {}
+  if (hasOperatorOverride())
+    return root3;
+  const home = effectiveHome();
+  const oldDir = join4(home, ".skills");
+  const oldConfigFile = join4(home, ".skillsrc");
   try {
-    mergeDirectoryContents(oldDir, newDir);
+    mergeDirectoryContents(oldDir, root3);
   } catch {}
-  if (existsSync(oldConfigFile) && !existsSync(join2(newDir, "config.json"))) {
+  if (existsSync2(oldConfigFile) && !existsSync2(join4(root3, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join2(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join4(root3, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root3;
 }
 
 // src/server/database-url.ts
-var DEFAULT_SQLITE_FILENAME = "server.db";
+var DEFAULT_SQLITE_FILENAME2 = "server.db";
 var SQLITE_MEMORY_PATH = ":memory:";
 var POSTGRES_SCHEMES = new Set(["postgres", "postgresql"]);
 var SQLITE_SCHEMES = new Set(["sqlite", "sqlite3", "file"]);
 var MEMORY_SCHEMES = new Set(["memory"]);
 var SQLITE_EXTENSIONS = [".db", ".sqlite", ".sqlite3", ".db3"];
 function defaultSqlitePath() {
-  return join3(getDataDir(), DEFAULT_SQLITE_FILENAME);
+  return join5(getDataDir(), DEFAULT_SQLITE_FILENAME2);
 }
 function resolveDatabaseTarget(raw) {
   const value = raw?.trim();
@@ -32998,7 +33104,7 @@ function resolveDatabaseTarget(raw) {
     throw new Error(`unsupported database scheme "${scheme}:". Supported: postgres://, postgresql://, sqlite:, file:, ` + `an absolute or relative path to a .db/.sqlite file, ":memory:", or "memory:" (non-durable, tests only). ` + `Leave the setting empty to use the default SQLite database at ${defaultSqlitePath()}.`);
   }
   if (looksLikeSqlitePath(value)) {
-    const path = isAbsolute(value) ? value : join3(process.cwd(), value);
+    const path = isAbsolute(value) ? value : join5(process.cwd(), value);
     return { kind: "sqlite", path, durable: true, label: `sqlite (${path})` };
   }
   throw new Error(`could not resolve a database backend from "${value}". Use postgres://\u2026, sqlite:\u2026, an absolute or ` + `relative path ending in ${SQLITE_EXTENSIONS.join("/")}, ":memory:", or leave it empty for the ` + `default SQLite database at ${defaultSqlitePath()}.`);
@@ -33022,7 +33128,7 @@ function sqlitePathFromUrl(value, scheme) {
     }
     return rest.slice(2).replace(/^\/\/+/, "/");
   }
-  return isAbsolute(rest) ? rest : join3(process.cwd(), rest);
+  return isAbsolute(rest) ? rest : join5(process.cwd(), rest);
 }
 function looksLikeSqlitePath(value) {
   if (value.includes("/"))
@@ -33034,7 +33140,7 @@ function looksLikeSqlitePath(value) {
 import { Database } from "bun:sqlite";
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 
 // src/server/auth.ts
 import { createHash as createHash3 } from "crypto";
@@ -33055,16 +33161,16 @@ function publicPrincipal(partial = {}) {
 }
 
 // src/server/migrations-dir.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 var MIGRATION_DIALECTS = ["postgres", "sqlite"];
 var MAX_WALK_UP = 6;
 function findMigrationsRoot(startDirs = defaultStartDirs()) {
   for (const start of startDirs) {
     let dir = start;
     for (let level = 0;level < MAX_WALK_UP; level += 1) {
-      const candidate = join4(dir, "migrations");
-      if (MIGRATION_DIALECTS.some((dialect) => existsSync2(join4(candidate, dialect))))
+      const candidate = join6(dir, "migrations");
+      if (MIGRATION_DIALECTS.some((dialect) => existsSync3(join6(candidate, dialect))))
         return candidate;
       const parent = dirname3(dir);
       if (parent === dir)
@@ -33078,8 +33184,8 @@ function resolveMigrationsDir(dialect, root3 = findMigrationsRoot()) {
   if (!root3) {
     throw new Error(`could not locate the migrations directory for dialect "${dialect}". ` + `Expected a migrations/${dialect}/ folder alongside the package root.`);
   }
-  const dir = join4(root3, dialect);
-  if (!existsSync2(dir)) {
+  const dir = join6(root3, dialect);
+  if (!existsSync3(dir)) {
     throw new Error(`migrations directory not found: ${dir}`);
   }
   return dir;
@@ -33823,7 +33929,7 @@ function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite"
   const appliedNow = [];
   for (const file of files) {
     const version2 = file.replace(/\.sql$/, "");
-    const text = readFileSync3(join5(migrationsDir, file), "utf8");
+    const text = readFileSync3(join7(migrationsDir, file), "utf8");
     const apply = db.transaction(() => {
       const already = db.query("SELECT 1 AS present FROM schema_migrations WHERE version = ? LIMIT 1").get(version2);
       if (already)
@@ -35727,19 +35833,19 @@ var FIRST_SEGMENT_COPY_EXCLUDES = new Set([
 // src/lib/portable-skills.ts
 var OFFICIAL_SKILL_NAMES = new Set(SKILLS.map((skill) => skill.name));
 // src/lib/installer.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, rmSync } from "fs";
-import { dirname as dirname5, join as join6 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, rmSync } from "fs";
+import { dirname as dirname5, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i3 = 0;i3 < 5; i3++) {
-    const candidate = join6(dir, "skills");
-    if (existsSync3(candidate) && !dir.includes(".skills"))
+    const candidate = join8(dir, "skills");
+    if (existsSync4(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname5(dir);
   }
-  return join6(__dirname2, "..", "skills");
+  return join8(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 
@@ -35794,13 +35900,13 @@ if (import.meta.main) {
       console.error(`worker ${workerId}: claim/execute failed (${consecutiveErrors} in a row):`, error.message);
       if (once)
         process.exit(1);
-      await new Promise((resolve) => setTimeout(resolve, Math.min(pause * consecutiveErrors, 30000)));
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(pause * consecutiveErrors, 30000)));
       continue;
     }
     if (once)
       process.exit(processed ? 0 : 2);
     if (!processed)
-      await new Promise((resolve) => setTimeout(resolve, pause));
+      await new Promise((resolve2) => setTimeout(resolve2, pause));
   } while (true);
 }
 export {

package/dist/cli/commands/hydrate.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerHydrate(parent: Command): void;

package/dist/index.d.ts

@@ -34,3 +34,6 @@ export { getFeedbackDbPath, saveFeedback, type FeedbackCategory, type FeedbackIn
 export { SKILLS_NATIVE_STORAGE_ENV, SKILLS_NATIVE_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_ENV, SKILLS_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_TABLES, STORAGE_TABLES, SkillsPostgresSyncStore, SkillsS3ObjectStore, buildSkillsS3ObjectUrl, createSkillsPostgresSyncStore, createSkillsS3ObjectStore, createSkillsSnapshotSyncRecord, exportSkillsLocalSnapshot, getSkillsNativeStorageStatus, getSkillsStorageDatabaseEnv, getSkillsStorageDatabaseUrl, getSkillsStorageStatus, getStorageDatabaseEnv, getStorageDatabaseUrl, getStorageStatus, importSkillsLocalSnapshot, planSkillsS3SnapshotUpload, resolveSkillsNativeStorageConfig, resolveStorageConfig, signSkillsAwsV4Request, skillsPostgresSyncSchemaSql, storageCapabilities, uploadSkillsSnapshotFilesToS3, type AwsCredentials, type SignSkillsAwsV4RequestOptions, type SkillsFetch, type SkillsLocalSnapshot, type SkillsNativeStorageConfig, type SkillsNativeStorageStatus, type SkillsPostgresQueryClient, type SkillsS3ObjectStoreOptions, type SkillsS3PutObjectOptions, type SkillsS3SnapshotPlanEntry, type SkillsS3StoredObject, type SkillsSnapshotFile, type SkillsStorageTable, type SkillsSyncRecord, } from "./lib/native-storage.js";
 export { SKILL_ALIASES, normalizeSkillSlug, resolveSkillAlias, type SkillAlias, } from "./lib/skill-aliases.js";
 export type { SkillResponse, SkillDetailResponse, CategoryResponse, TagResponse, InstallResponse, RemoveResponse, VersionResponse, ExportResponse, ImportResponse, SearchResponse, CategoryInstallResponse, ErrorResponse, } from "./types/api.js";
+export { STATION_SYNC_MANIFEST_SCHEMA, StationSnapshotError, sha256File, planStationSnapshot, validateStationId, writeStationSnapshot, type PortableSnapshotFile, type ScannedHome, type SnapshotPlan, type StationSnapshotErrorCode, type StationSnapshotManifestFile, type StationSnapshotOptions, type StationSnapshotResult, } from "./lib/station-snapshot.js";
+export { STATION_HYDRATION_MANIFEST_SCHEMA, planStationHydration, writeStationHydration, type HydrationCandidate, type HydrationWinnerFile, type HydrationWinnerSkill, type StationHydrationOptions, type StationHydrationResult, } from "./lib/station-hydrate.js";
+export { REFUSED_SCANNER_FLAGGED, SYNC_HOMES, destinationFor, homePathFor, isExcludedSkillFileName, isPortableWithinSkill, isRegularFile, walkEntries, type SyncHomeDefinition, type WalkEntry, } from "./lib/portable-snapshot-filter.js";