@hasna/skills 0.1.71 → 0.2.0

package/bin/migrate.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/server/migrate.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
 
 // src/lib/retired-settings.ts
 var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
@@ -56,6 +56,7 @@ function resolveServerConfig(env = process.env) {
     port,
     databaseUrl: env[DATABASE_URL_ENV] || env.DATABASE_URL || undefined,
     bootstrapApiKey: env.HASNA_SKILLS_BOOTSTRAP_API_KEY || undefined,
+    seedBundledCorpus: (env.HASNA_SKILLS_SEED_BUNDLED_CORPUS ?? "1") !== "0",
     artifactBucket: env.HASNA_SKILLS_S3_BUCKET || env.SKILLS_S3_BUCKET || undefined,
     artifactPrefix: normalizePrefix(env.HASNA_SKILLS_S3_PREFIX || env.SKILLS_S3_PREFIX || "skills/artifacts"),
     inlineWorker: env.HASNA_SKILLS_INLINE_WORKER === "1",
@@ -81,65 +82,167 @@ function normalizePrefix(value) {
 }
 
 // src/server/database-url.ts
-import { isAbsolute, join as join2 } from "path";
+import { isAbsolute, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join2, dirname } from "path";
+
+// src/lib/app-home.ts
+import { existsSync } from "fs";
 import { homedir } from "os";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+var PATHS_RESOLVER_KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_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 pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
+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"] || homedir() || "/tmp";
+}
+function legacyDataRoot() {
+  return join(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome(), env) {
+  return dataDir({ app: "skills", home, env });
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join(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 = join(sourceDir, entry);
-    const targetPath = join(targetDir, entry);
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(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"] || homedir();
-  const newDir = join(home, ".hasna", "skills");
-  const oldDir = join(home, ".skills");
-  const oldConfigFile = join(home, ".skillsrc");
-  mkdirSync(newDir, { recursive: true });
+  const root = getDataRoot();
   try {
-    mergeDirectoryContents(oldDir, newDir);
+    mkdirSync(root, { recursive: true });
   } catch {}
-  if (existsSync(oldConfigFile) && !existsSync(join(newDir, "config.json"))) {
+  if (hasOperatorOverride())
+    return root;
+  const home = effectiveHome();
+  const oldDir = join2(home, ".skills");
+  const oldConfigFile = join2(home, ".skillsrc");
+  try {
+    mergeDirectoryContents(oldDir, root);
+  } catch {}
+  if (existsSync2(oldConfigFile) && !existsSync2(join2(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join2(root, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root;
 }
 
 // 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 join2(getDataDir(), DEFAULT_SQLITE_FILENAME);
+  return join3(getDataDir(), DEFAULT_SQLITE_FILENAME2);
 }
 function resolveDatabaseTarget(raw) {
   const value = raw?.trim();
@@ -166,7 +269,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 : join2(process.cwd(), value);
+    const path = isAbsolute(value) ? value : join3(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()}.`);
@@ -190,7 +293,7 @@ function sqlitePathFromUrl(value, scheme) {
     }
     return rest.slice(2).replace(/^\/\/+/, "/");
   }
-  return isAbsolute(rest) ? rest : join2(process.cwd(), rest);
+  return isAbsolute(rest) ? rest : join3(process.cwd(), rest);
 }
 function looksLikeSqlitePath(value) {
   if (value.includes("/"))
@@ -199,16 +302,16 @@ function looksLikeSqlitePath(value) {
 }
 
 // src/server/migrations-dir.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, join as join4 } 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 = join3(dir, "migrations");
-      if (MIGRATION_DIALECTS.some((dialect) => existsSync2(join3(candidate, dialect))))
+      const candidate = join4(dir, "migrations");
+      if (MIGRATION_DIALECTS.some((dialect) => existsSync3(join4(candidate, dialect))))
         return candidate;
       const parent = dirname2(dir);
       if (parent === dir)
@@ -222,8 +325,8 @@ function resolveMigrationsDir(dialect, root = findMigrationsRoot()) {
   if (!root) {
     throw new Error(`could not locate the migrations directory for dialect "${dialect}". ` + `Expected a migrations/${dialect}/ folder alongside the package root.`);
   }
-  const dir = join3(root, dialect);
-  if (!existsSync2(dir)) {
+  const dir = join4(root, dialect);
+  if (!existsSync3(dir)) {
     throw new Error(`migrations directory not found: ${dir}`);
   }
   return dir;
@@ -240,7 +343,7 @@ function defaultStartDirs() {
 import { Database } from "bun:sqlite";
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 
 // src/server/auth.ts
 import { createHash } from "crypto";
@@ -532,6 +635,20 @@ function dateString(value) {
     return value.toISOString();
   return String(value);
 }
+function rowToSkillVersion(row) {
+  return {
+    orgId: String(row.org_id),
+    slug: String(row.slug),
+    version: String(row.version),
+    bundleSha256: String(row.bundle_sha256),
+    bundleByteSize: Number(row.bundle_byte_size),
+    storageKind: String(row.storage_kind ?? "db"),
+    ...typeof row.storage_key === "string" ? { storageKey: row.storage_key } : {},
+    manifest: parseJsonObject(row.manifest_json),
+    ...typeof row.published_by_user_id === "string" ? { publishedByUserId: row.published_by_user_id } : {},
+    createdAt: dateString(row.created_at)
+  };
+}
 
 // src/server/types.ts
 class StaleLeaseGenerationError extends Error {
@@ -562,6 +679,21 @@ class SkillRevisionConflictError extends Error {
   }
 }
 
+class SkillVersionExistsError extends Error {
+  slug;
+  version;
+  existingSha256;
+  attemptedSha256;
+  constructor(slug, version, existingSha256, attemptedSha256) {
+    super(`version conflict for '${slug}@${version}': already published with bundle ${existingSha256}, ` + `refusing to overwrite it with ${attemptedSha256}. Publish a new version instead.`);
+    this.slug = slug;
+    this.version = version;
+    this.existingSha256 = existingSha256;
+    this.attemptedSha256 = attemptedSha256;
+    this.name = "SkillVersionExistsError";
+  }
+}
+
 // src/lib/revision.ts
 import { createHash as createHash2 } from "crypto";
 function revisionIdOf(content) {
@@ -857,6 +989,13 @@ class SqliteSkillsStore {
         throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previousRevisionId);
       }
       const carriedSha = input.bundle?.sha256 ?? previousSha;
+      if (input.version && carriedSha) {
+        const existingVersion = this.get("SELECT bundle_sha256 FROM skills_versions WHERE org_id = ? AND slug = ? AND version = ? LIMIT 1", [orgId, input.slug, input.version]);
+        const existingSha = typeof existingVersion?.bundle_sha256 === "string" ? existingVersion.bundle_sha256 : null;
+        if (existingSha && existingSha !== carriedSha) {
+          throw new SkillVersionExistsError(input.slug, input.version, existingSha, carriedSha);
+        }
+      }
       const carriedSize = input.bundle?.byteSize ?? (previous?.bundle_byte_size == null ? null : Number(previous.bundle_byte_size));
       const revisionId = revisionIdOfRecord({
         slug: input.slug,
@@ -944,6 +1083,21 @@ class SqliteSkillsStore {
         const currentId = typeof current?.revision_id === "string" ? current.revision_id : null;
         throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, currentId);
       }
+      if (input.version && carriedSha) {
+        this.db.run(`INSERT OR IGNORE INTO skills_versions (org_id, slug, version, bundle_sha256, bundle_byte_size, storage_kind, storage_key, manifest_json, published_by_user_id, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+          orgId,
+          input.slug,
+          input.version,
+          carriedSha,
+          carriedSize ?? 0,
+          input.versionStorage?.storageKind ?? "db",
+          input.versionStorage?.storageKey ?? null,
+          JSON.stringify(input.versionManifest ?? {}),
+          input.principal.userId ?? null,
+          now
+        ]);
+      }
       if (previousSha && input.bundle && previousSha !== input.bundle.sha256)
         this.collectOrphanBundle(orgId, previousSha);
       this.db.run("DELETE FROM skills_tags WHERE org_id = ? AND slug = ?", [orgId, input.slug]);
@@ -1051,6 +1205,13 @@ class SqliteSkillsStore {
     const row = this.get("SELECT * FROM skills_bundles WHERE org_id = ? AND sha256 = ? LIMIT 1", [principal.orgId, sha256]);
     return row ? rowToSkillBundle(row) : null;
   }
+  async listSkillVersions(principal, slug) {
+    return this.all("SELECT * FROM skills_versions WHERE org_id = ? AND slug = ? ORDER BY created_at DESC, version DESC", [principal.orgId, slug]).map(rowToSkillVersion);
+  }
+  async getSkillVersion(principal, slug, version) {
+    const row = this.get("SELECT * FROM skills_versions WHERE org_id = ? AND slug = ? AND version = ? LIMIT 1", [principal.orgId, slug, version]);
+    return row ? rowToSkillVersion(row) : null;
+  }
   async pinSkill(principal, slug, metadata = {}) {
     const row = this.get(`INSERT INTO skills_pins (org_id, principal, slug, pinned_at, metadata_json)
        VALUES (?, ?, ?, ?, ?)
@@ -1090,7 +1251,7 @@ class SqliteSkillsStore {
     return this.all("SELECT slug FROM skills_registry WHERE org_id = ? AND tombstoned_at IS NULL ORDER BY slug ASC", [principal.orgId]).map((row) => String(row.slug));
   }
   collectOrphanBundle(orgId, sha256) {
-    const referenced = this.get("SELECT 1 AS present FROM skills_registry WHERE org_id = ? AND bundle_sha256 = ? LIMIT 1", [orgId, sha256]);
+    const referenced = this.get("SELECT 1 AS present FROM skills_registry WHERE org_id = ? AND bundle_sha256 = ? LIMIT 1", [orgId, sha256]) ?? this.get("SELECT 1 AS present FROM skills_versions WHERE org_id = ? AND bundle_sha256 = ? LIMIT 1", [orgId, sha256]);
     if (referenced)
       return;
     this.db.run("DELETE FROM skills_bundles WHERE org_id = ? AND sha256 = ?", [orgId, sha256]);
@@ -1119,7 +1280,7 @@ function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite"
   const appliedNow = [];
   for (const file of files) {
     const version = file.replace(/\.sql$/, "");
-    const text = readFileSync2(join4(migrationsDir, file), "utf8");
+    const text = readFileSync2(join5(migrationsDir, file), "utf8");
     const apply = db.transaction(() => {
       const already = db.query("SELECT 1 AS present FROM schema_migrations WHERE version = ? LIMIT 1").get(version);
       if (already)
@@ -1192,7 +1353,7 @@ async function runMigrations(databaseUrl, migrationsDir) {
   return { backend: "postgres", applied: await runPostgresMigrations(target.url, migrationsDir ?? resolveMigrationsDir("postgres")) };
 }
 async function runPostgresMigrations(databaseUrl, migrationsDir) {
-  if (!existsSync3(migrationsDir))
+  if (!existsSync4(migrationsDir))
     throw new Error(`migrations directory not found: ${migrationsDir}`);
   const bunWithSql = Bun;
   const sql = new bunWithSql.SQL(databaseUrl, { max: 1 });
@@ -1208,7 +1369,7 @@ async function runPostgresMigrations(databaseUrl, migrationsDir) {
       const version = file.replace(/\.sql$/, "");
       if (applied.has(version))
         continue;
-      const sqlText = readFileSync3(join5(migrationsDir, file), "utf8");
+      const sqlText = readFileSync3(join6(migrationsDir, file), "utf8");
       await sql.unsafe("BEGIN");
       try {
         await sql.unsafe(sqlText);