@hasna/skills 0.1.72 → 0.2.1

package/bin/migrate.js

@@ -3,7 +3,7 @@
 
 // src/server/migrate.ts
 import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join7 } from "path";
+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,103 +82,96 @@ function normalizePrefix(value) {
 }
 
 // src/server/database-url.ts
-import { isAbsolute, join as join4 } from "path";
+import { isAbsolute, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/config.ts
 import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join as join3, dirname } from "path";
+import { join as join2, dirname } from "path";
 
 // src/lib/app-home.ts
 import { existsSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, resolve } from "path";
-
-// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
 import { homedir } from "os";
-import { join } from "path";
-var KIND_ENV = {
+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 APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function assertApp(app) {
+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 (!APP_SLUG_RE.test(app)) {
+  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 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 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 baseDir(kind, options) {
-  const override = envValue(options, kind);
-  if (override)
+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 ?? homedir();
+  const home = options.home ?? pathsResolverHomedir();
   const platform = options.platform ?? process.platform;
-  if (isMacOS(platform)) {
+  if (platform === "darwin") {
     switch (kind) {
       case "config":
       case "data":
-        return join(home, "Library", "Application Support", "Hasna");
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
       case "cache":
-        return join(home, "Library", "Caches", "Hasna");
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
       case "state":
-        return join(home, "Library", "Logs", "Hasna");
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
     }
   }
   switch (kind) {
     case "config":
-      return join(home, ".config", "hasna");
+      return pathsResolverJoin(home, ".config", "hasna");
     case "data":
-      return join(home, ".local", "share", "hasna");
+      return pathsResolverJoin(home, ".local", "share", "hasna");
     case "state":
-      return join(home, ".local", "state", "hasna");
+      return pathsResolverJoin(home, ".local", "state", "hasna");
     case "cache":
-      return join(home, ".cache", "hasna");
+      return pathsResolverJoin(home, ".cache", "hasna");
   }
 }
-function resolvePath(kind, options) {
-  assertApp(options.app);
-  const appSegment = options.internal === true ? join("internal", options.app) : options.app;
-  return join(baseDir(kind, options), appSegment);
+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 resolvePath("data", options);
+  return pathsResolverResolve("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"] || homedir2() || "/tmp";
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir() || "/tmp";
 }
 function legacyDataRoot() {
-  return join2(effectiveHome(), ".hasna", "skills");
+  return join(effectiveHome(), ".hasna", "skills");
 }
-function resolverDataRoot(home = effectiveHome()) {
-  return dataDir({ app: "skills", home });
+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(join2(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join2(resolved, GLOBAL_CONFIG_FILENAME));
+  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]) {
@@ -206,8 +200,8 @@ function mergeDirectoryContents(sourceDir, targetDir) {
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join3(sourceDir, entry);
-    const targetPath = join3(targetDir, entry);
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
@@ -227,14 +221,14 @@ function getDataDir() {
   if (hasOperatorOverride())
     return root;
   const home = effectiveHome();
-  const oldDir = join3(home, ".skills");
-  const oldConfigFile = join3(home, ".skillsrc");
+  const oldDir = join2(home, ".skills");
+  const oldConfigFile = join2(home, ".skillsrc");
   try {
     mergeDirectoryContents(oldDir, root);
   } catch {}
-  if (existsSync2(oldConfigFile) && !existsSync2(join3(root, "config.json"))) {
+  if (existsSync2(oldConfigFile) && !existsSync2(join2(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join3(root, "config.json"));
+      copyFileSync(oldConfigFile, join2(root, "config.json"));
     } catch {}
   }
   return root;
@@ -248,7 +242,7 @@ var SQLITE_SCHEMES = new Set(["sqlite", "sqlite3", "file"]);
 var MEMORY_SCHEMES = new Set(["memory"]);
 var SQLITE_EXTENSIONS = [".db", ".sqlite", ".sqlite3", ".db3"];
 function defaultSqlitePath() {
-  return join4(getDataDir(), DEFAULT_SQLITE_FILENAME2);
+  return join3(getDataDir(), DEFAULT_SQLITE_FILENAME2);
 }
 function resolveDatabaseTarget(raw) {
   const value = raw?.trim();
@@ -275,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 : join4(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()}.`);
@@ -299,7 +293,7 @@ function sqlitePathFromUrl(value, scheme) {
     }
     return rest.slice(2).replace(/^\/\/+/, "/");
   }
-  return isAbsolute(rest) ? rest : join4(process.cwd(), rest);
+  return isAbsolute(rest) ? rest : join3(process.cwd(), rest);
 }
 function looksLikeSqlitePath(value) {
   if (value.includes("/"))
@@ -309,15 +303,15 @@ function looksLikeSqlitePath(value) {
 
 // src/server/migrations-dir.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
+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 = join5(dir, "migrations");
-      if (MIGRATION_DIALECTS.some((dialect) => existsSync3(join5(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)
@@ -331,7 +325,7 @@ 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 = join5(root, dialect);
+  const dir = join4(root, dialect);
   if (!existsSync3(dir)) {
     throw new Error(`migrations directory not found: ${dir}`);
   }
@@ -349,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 join6 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 
 // src/server/auth.ts
 import { createHash } from "crypto";
@@ -641,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 {
@@ -671,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) {
@@ -966,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,
@@ -1053,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]);
@@ -1160,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 (?, ?, ?, ?, ?)
@@ -1199,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]);
@@ -1228,7 +1280,7 @@ function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite"
   const appliedNow = [];
   for (const file of files) {
     const version = file.replace(/\.sql$/, "");
-    const text = readFileSync2(join6(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)
@@ -1317,7 +1369,7 @@ async function runPostgresMigrations(databaseUrl, migrationsDir) {
       const version = file.replace(/\.sql$/, "");
       if (applied.has(version))
         continue;
-      const sqlText = readFileSync3(join7(migrationsDir, file), "utf8");
+      const sqlText = readFileSync3(join6(migrationsDir, file), "utf8");
       await sql.unsafe("BEGIN");
       try {
         await sql.unsafe(sqlText);