@saluzi/saluzi-edu 0.2.26 → 0.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saluzi/saluzi-edu",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Saluzi CLI - interactive AI coding assistant in the terminal",
   "license": "MIT",
   "type": "module",

package/packages/remote-control-server/src/db/rcs-schema.sql

@@ -0,0 +1,121 @@
+-- RCS Authentication & Session Schema
+-- Phase 1: users, session_tokens, invitations
+-- Phase 2: teams, team_members, team_environments, session_owners, session_shares, sessions
+
+CREATE TABLE IF NOT EXISTS users (
+  id TEXT NOT NULL PRIMARY KEY,
+  username TEXT UNIQUE NOT NULL,
+  password_hash TEXT NOT NULL,
+  role TEXT NOT NULL CHECK (role IN ('admin', 'member', 'guest')),
+  created_at TEXT NOT NULL,
+  last_login_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS session_tokens (
+  token_hash TEXT NOT NULL PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id),
+  kind TEXT NOT NULL CHECK (kind IN ('access', 'refresh')),
+  expires_at TEXT NOT NULL,
+  revoked_at TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS invitations (
+  token_hash TEXT NOT NULL PRIMARY KEY,
+  team_id TEXT,
+  role TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  max_uses INTEGER DEFAULT 1,
+  uses INTEGER DEFAULT 0,
+  created_by TEXT NOT NULL REFERENCES users(id),
+  consumed_at TEXT,
+  consumed_by TEXT REFERENCES users(id)
+);
+
+-- Phase 2 tables
+
+CREATE TABLE IF NOT EXISTS teams (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  slug TEXT UNIQUE NOT NULL,
+  description TEXT,
+  created_by TEXT NOT NULL REFERENCES users(id),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  deleted_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS team_members (
+  team_id TEXT NOT NULL REFERENCES teams(id),
+  user_id TEXT NOT NULL REFERENCES users(id),
+  role TEXT NOT NULL CHECK (role IN ('owner', 'admin', 'member')),
+  added_at TEXT NOT NULL,
+  added_by TEXT NOT NULL REFERENCES users(id),
+  PRIMARY KEY (team_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS team_environments (
+  team_id TEXT NOT NULL REFERENCES teams(id),
+  environment_id TEXT NOT NULL,
+  PRIMARY KEY (team_id, environment_id)
+);
+
+CREATE TABLE IF NOT EXISTS session_owners (
+  session_id TEXT NOT NULL,
+  owner_type TEXT NOT NULL CHECK (owner_type IN ('user', 'team')),
+  owner_id TEXT NOT NULL,
+  PRIMARY KEY (session_id, owner_type, owner_id)
+);
+
+CREATE TABLE IF NOT EXISTS session_shares (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  granted_to_user TEXT REFERENCES users(id),
+  granted_to_team TEXT REFERENCES teams(id),
+  permission TEXT NOT NULL CHECK (permission IN ('read', 'write')),
+  expires_at TEXT,
+  granted_by TEXT NOT NULL REFERENCES users(id),
+  granted_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS environments (
+  id TEXT PRIMARY KEY,
+  secret_hash TEXT NOT NULL,
+  team_id TEXT,
+  registered_by TEXT,
+  machine_name TEXT,
+  worker_type TEXT NOT NULL DEFAULT 'claude_code',
+  status TEXT NOT NULL DEFAULT 'active',
+  last_poll_at TEXT,
+  created_at TEXT NOT NULL,
+  owner_user_id TEXT,
+  claim_token TEXT,
+  claim_expires_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  environment_id TEXT,
+  title TEXT,
+  status TEXT NOT NULL DEFAULT 'idle',
+  source TEXT NOT NULL DEFAULT 'remote-control',
+  visibility TEXT NOT NULL DEFAULT 'private',
+  permission_mode TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+-- Performance indexes
+CREATE INDEX IF NOT EXISTS idx_session_owners_owner ON session_owners(owner_type, owner_id);
+CREATE INDEX IF NOT EXISTS idx_session_owners_session ON session_owners(session_id);
+CREATE INDEX IF NOT EXISTS idx_team_members_user ON team_members(user_id);
+CREATE INDEX IF NOT EXISTS idx_team_members_team ON team_members(team_id);
+CREATE INDEX IF NOT EXISTS idx_session_shares_user ON session_shares(granted_to_user);
+CREATE INDEX IF NOT EXISTS idx_session_shares_team ON session_shares(granted_to_team);
+CREATE INDEX IF NOT EXISTS idx_session_shares_session ON session_shares(session_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_visibility ON sessions(visibility);
+CREATE INDEX IF NOT EXISTS idx_sessions_environment ON sessions(environment_id);
+CREATE INDEX IF NOT EXISTS idx_session_tokens_user ON session_tokens(user_id);
+CREATE INDEX IF NOT EXISTS idx_environments_team ON environments(team_id);
+CREATE INDEX IF NOT EXISTS idx_environments_owner_user ON environments(owner_user_id);
+CREATE INDEX IF NOT EXISTS idx_environments_claim_token ON environments(claim_token);

package/packages/remote-control-server/src/db/sqlite.ts

@@ -42,9 +42,33 @@ const ResolvedDatabase: DatabaseCtor = (() => {
   }
 
   // Tier 3: libsql (optionalDependency — covers Node 20/21)
+  // libsql 0.5.x exports the Database constructor directly (better-sqlite3
+  // compatible API): `require('libsql')` returns a function, not an object
+  // with a `.Database` property. Check `typeof === 'function'` and call
+  // `new libsql(path)` directly.
+  //
+  // Parameter format compatibility: bun:sqlite and node:sqlite both accept
+  // `$name` named params, but libsql (better-sqlite3 lineage) only accepts
+  // `:name` and `@name` — `$name` silently fails to bind, causing
+  // "NOT NULL constraint failed" errors. Convert `$name` → `:name` in SQL
+  // and `{$name: v}` → `{name: v}` in param objects so RCS queries work
+  // unchanged across all three backends.
   try {
     const libsql = require('libsql')
-    if (libsql?.Database) {
+    if (typeof libsql === 'function') {
+      const convertSql = (sql: string): string => sql.replace(/\$(\w+)/g, ':$1')
+      const convertParams = (params: unknown[]): unknown[] =>
+        params.map(p => {
+          if (p && typeof p === 'object' && !Array.isArray(p)) {
+            const obj = p as Record<string, unknown>
+            const out: Record<string, unknown> = {}
+            for (const k of Object.keys(obj)) {
+              out[k.startsWith('$') ? k.slice(1) : k] = obj[k]
+            }
+            return out
+          }
+          return p
+        })
       return class LibsqlCompat {
         private _db: {
           prepare(sql: string): {
@@ -56,17 +80,17 @@ const ResolvedDatabase: DatabaseCtor = (() => {
           close(): void
         }
         constructor(path: string) {
-          this._db = new libsql.Database(path)
+          this._db = new libsql(path)
         }
         exec(sql: string): void {
           this._db.exec(sql)
         }
         query(sql: string) {
-          const stmt = this._db.prepare(sql)
+          const stmt = this._db.prepare(convertSql(sql))
           return {
-            get: (...params: unknown[]) => stmt.get(...params),
-            all: (...params: unknown[]) => stmt.all(...params),
-            run: (...params: unknown[]) => stmt.run(...params),
+            get: (...params: unknown[]) => stmt.get(...convertParams(params)),
+            all: (...params: unknown[]) => stmt.all(...convertParams(params)),
+            run: (...params: unknown[]) => stmt.run(...convertParams(params)),
           }
         }
         close(): void {
@@ -92,15 +116,20 @@ let _dbPath: string | null = null
  * Idempotent — uses CREATE TABLE IF NOT EXISTS for new tables, plus
  * ALTER TABLE ADD COLUMN for columns added to existing tables (gated by
  * PRAGMA table_info so re-running on an already-migrated DB is a no-op).
- * Reads schema.sql and executes as a single db.exec() call,
+ * Reads rcs-schema.sql and executes as a single db.exec() call,
  * which correctly handles semicolons inside CHECK constraints.
+ *
+ * File is named rcs-schema.sql (not schema.sql) to avoid collision with
+ * CodeGraph's schema.sql at the same dist/ path — both modules resolve
+ * their schema via __dirname, and the bundler places them in the same
+ * chunk directory.
  */
 export function migrateDatabase(db: Database): void {
-  const schemaPath = resolve(__dirname, 'schema.sql')
+  const schemaPath = resolve(__dirname, 'rcs-schema.sql')
   const schema = readFileSync(schemaPath, 'utf8')
 
   db.exec('PRAGMA foreign_keys = ON')
-  // Run ALTER TABLE migrations BEFORE db.exec(schema) — schema.sql's
+  // Run ALTER TABLE migrations BEFORE db.exec(schema) — rcs-schema.sql's
   // CREATE INDEX statements reference the new columns, so the columns
   // must exist before the indexes can be created. CREATE TABLE IF NOT
   // EXISTS skips existing tables (so the ALTER adds the missing columns
@@ -116,7 +145,7 @@ export function migrateDatabase(db: Database): void {
  * before owner_user_id / claim_token / claim_expires_at existed.
  * CREATE TABLE IF NOT EXISTS skips existing tables entirely, so without
  * this the new columns would never appear on upgraded DBs. Must run
- * BEFORE db.exec(schema) because schema.sql's CREATE INDEX statements
+ * BEFORE db.exec(schema) because rcs-schema.sql's CREATE INDEX statements
  * reference the new columns. On a fresh DB (table doesn't exist yet),
  * skip entirely — db.exec(schema) will create the table with all columns.
  */