@julioventura/opensquad 0.1.17

package/src/supabase-cli.js

@@ -0,0 +1,584 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+
+const DEFAULT_WORKSPACE_SLUG = 'contexto-informatica';
+const DEFAULT_WORKSPACE_NAME = 'Contexto Informática';
+const DEFAULT_BUCKET = 'os-artifacts';
+const REQUIRED_TABLES = [
+  'os_workspaces',
+  'os_squads',
+  'os_skills',
+  'os_runs',
+  'os_run_state_snapshots',
+  'os_artifacts',
+  'os_events',
+];
+
+export async function supabaseCli(subcommand, args = [], targetDir = process.cwd()) {
+  if (subcommand === 'doctor' || !subcommand) {
+    return runDoctor(targetDir);
+  }
+  if (subcommand === 'import') {
+    return runImport(targetDir, parseFlags(args));
+  }
+  if (subcommand === 'mirror') {
+    return runMirror(targetDir, parseFlags(args));
+  }
+
+  console.log(`
+  Unknown Supabase command: ${subcommand}
+
+  Usage:
+    npx @julioventura/opensquad supabase doctor
+    npx @julioventura/opensquad supabase import [--dry-run]
+    npx @julioventura/opensquad supabase mirror --squad <name> --run-id <run-id>
+  `);
+  return { success: false };
+}
+
+export async function runDoctor(targetDir = process.cwd()) {
+  console.log('\n  Opensquad Supabase Doctor\n');
+
+  const env = await loadEnv(targetDir);
+  const checks = [];
+
+  const url = env.OS_SUPABASE_URL || env.SUPABASE_URL;
+  const serviceRoleKey = env.OS_SUPABASE_SERVICE_ROLE_KEY || env.SUPABASE_SERVICE_ROLE_KEY;
+  const dbUrl = env.OS_SUPABASE_DB_URL;
+  const bucket = env.OS_SUPABASE_STORAGE_BUCKET || DEFAULT_BUCKET;
+
+  checks.push(['OS_SUPABASE_URL', Boolean(url)]);
+  checks.push(['OS_SUPABASE_SERVICE_ROLE_KEY', Boolean(serviceRoleKey)]);
+  checks.push(['OS_SUPABASE_DB_URL', Boolean(dbUrl), 'optional for CLI, required for psql fallback']);
+
+  let client;
+  try {
+    client = await createSupabaseClient(env);
+    checks.push(['@supabase/supabase-js', true]);
+  } catch (err) {
+    checks.push(['@supabase/supabase-js', false, err.message]);
+  }
+
+  if (client) {
+    for (const table of REQUIRED_TABLES) {
+      const result = await client.from(table).select('id').limit(1);
+      checks.push([table, isOk(result), formatSupabaseError(result)]);
+    }
+
+    const bucketResult = await client.storage.getBucket(bucket);
+    checks.push([`storage bucket ${bucket}`, Boolean(bucketResult.data) && !bucketResult.error, formatSupabaseError(bucketResult)]);
+  }
+
+  printChecks(checks);
+  const success = checks.every((check) => check[1] || check[2]?.startsWith('optional'));
+  console.log(success ? '\n  Supabase configuration looks ready.\n' : '\n  Supabase configuration is incomplete.\n');
+  return { success };
+}
+
+export async function runImport(targetDir = process.cwd(), options = {}) {
+  const dryRun = Boolean(options['dry-run']);
+  const inventory = await buildInventory(targetDir);
+
+  console.log(`\n  Opensquad Supabase Import${dryRun ? ' (dry run)' : ''}\n`);
+  printInventory(inventory);
+
+  if (dryRun) {
+    console.log('\n  Dry run complete. No Supabase data was changed.\n');
+    return { success: true, inventory };
+  }
+
+  const env = await loadEnv(targetDir);
+  const client = await createSupabaseClient(env);
+  const workspace = await ensureWorkspace(client, env);
+
+  await importSkills(client, workspace.id, inventory.skills);
+  await importSquads(client, workspace.id, inventory.squads);
+  await importMemoryArtifacts(client, workspace.id, inventory.memoryFiles);
+  await insertEvent(client, workspace.id, 'import.completed', {
+    counts: {
+      skills: inventory.skills.length,
+      squads: inventory.squads.length,
+      memoryFiles: inventory.memoryFiles.length,
+    },
+  });
+
+  console.log('\n  Import complete.\n');
+  return { success: true, inventory };
+}
+
+export async function runMirror(targetDir = process.cwd(), options = {}) {
+  const squad = options.squad;
+  const runId = options['run-id'];
+
+  if (!squad || !runId) {
+    console.log('\n  Usage: opensquad supabase mirror --squad <name> --run-id <run-id>\n');
+    return { success: false };
+  }
+
+  const env = await loadEnv(targetDir);
+  if ((env.OS_SUPABASE_MODE || '').toLowerCase() === 'off') {
+    console.log('\n  Supabase mirror skipped because OS_SUPABASE_MODE=off.\n');
+    return { success: true, skipped: true };
+  }
+
+  const client = await createSupabaseClient(env);
+  const workspace = await ensureWorkspace(client, env);
+  const runDir = await findRunDir(targetDir, squad, runId);
+  if (!runDir) {
+    console.log(`\n  Run folder not found for ${squad}/${runId}.\n`);
+    return { success: false };
+  }
+
+  const statePath = join(runDir, 'state.json');
+  const state = await readJsonFile(statePath);
+  const run = await upsertRun(client, workspace.id, squad, runId, runDir, state);
+  if (state) {
+    await insertStateSnapshot(client, workspace.id, run.id, squad, runId, statePath, state);
+  }
+
+  const artifacts = await collectArtifacts(targetDir, runDir, { limitBytes: Number(env.OS_SUPABASE_MIRROR_MAX_ARTIFACT_BYTES || 0) });
+  await upsertArtifacts(client, workspace.id, run.id, squad, runId, artifacts);
+  await insertEvent(client, workspace.id, 'mirror.completed', {
+    squad,
+    runId,
+    artifactCount: artifacts.length,
+    stateFound: Boolean(state),
+  }, run.id);
+
+  console.log(`\n  Mirrored ${squad}/${runId}: ${artifacts.length} artifact metadata records.\n`);
+  return { success: true, artifacts };
+}
+
+async function createSupabaseClient(env) {
+  const url = env.OS_SUPABASE_URL || env.SUPABASE_URL;
+  const key = env.OS_SUPABASE_SERVICE_ROLE_KEY || env.SUPABASE_SERVICE_ROLE_KEY;
+  if (!url) throw new Error('Missing OS_SUPABASE_URL.');
+  if (!key) throw new Error('Missing OS_SUPABASE_SERVICE_ROLE_KEY.');
+
+  let module;
+  try {
+    module = await import('@supabase/supabase-js');
+  } catch (err) {
+    throw new Error('Missing dependency @supabase/supabase-js. Run npm install.', { cause: err });
+  }
+
+  return module.createClient(url, key, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    },
+  });
+}
+
+async function ensureWorkspace(client, env) {
+  const id = env.OS_SUPABASE_WORKSPACE_ID || undefined;
+  const slug = env.OS_SUPABASE_WORKSPACE_SLUG || DEFAULT_WORKSPACE_SLUG;
+  const name = env.OS_SUPABASE_WORKSPACE_NAME || DEFAULT_WORKSPACE_NAME;
+  const payload = id ? { id, slug, name } : { slug, name };
+  const onConflict = id ? 'id' : 'slug';
+  const { data, error } = await client
+    .from('os_workspaces')
+    .upsert(payload, { onConflict })
+    .select()
+    .single();
+
+  if (error) throw new Error(`Unable to upsert workspace: ${formatSupabaseError({ error, status: data?.status })}`);
+  return data;
+}
+
+async function importSkills(client, workspaceId, skills) {
+  if (skills.length === 0) return;
+  const rows = skills.map((skill) => ({
+    workspace_id: workspaceId,
+    slug: skill.slug,
+    name: skill.frontmatter.name || skill.slug,
+    type: skill.frontmatter.type || null,
+    version: skill.frontmatter.version || null,
+    source_path: skill.path,
+    frontmatter: skill.frontmatter,
+    content_hash: skill.hash,
+    metadata: { byteSize: skill.byteSize },
+  }));
+  const { error } = await client.from('os_skills').upsert(rows, { onConflict: 'workspace_id,slug' });
+  if (error) throw new Error(`Unable to import skills: ${formatSupabaseError({ error })}`);
+}
+
+async function importSquads(client, workspaceId, squads) {
+  if (squads.length === 0) return;
+  const rows = squads.map((squad) => ({
+    workspace_id: workspaceId,
+    slug: squad.slug,
+    name: squad.name || squad.slug,
+    source_path: squad.path,
+    config: { squadYaml: squad.content },
+    content_hash: squad.hash,
+    metadata: { byteSize: squad.byteSize },
+  }));
+  const { error } = await client.from('os_squads').upsert(rows, { onConflict: 'workspace_id,slug' });
+  if (error) throw new Error(`Unable to import squads: ${formatSupabaseError({ error })}`);
+}
+
+async function importMemoryArtifacts(client, workspaceId, memoryFiles) {
+  if (memoryFiles.length === 0) return;
+  const rows = memoryFiles.map((file) => ({
+    workspace_id: workspaceId,
+    relative_path: file.path,
+    artifact_type: 'memory',
+    byte_size: file.byteSize,
+    content_hash: file.hash,
+    metadata: { preview: file.preview },
+  }));
+  const { error } = await client.from('os_artifacts').upsert(rows, { onConflict: 'workspace_id,relative_path,content_hash' });
+  if (error) throw new Error(`Unable to import memory artifacts: ${formatSupabaseError({ error })}`);
+}
+
+async function upsertRun(client, workspaceId, squad, runId, runDir, state) {
+  const { data: squadRecord } = await client
+    .from('os_squads')
+    .select('id')
+    .eq('workspace_id', workspaceId)
+    .eq('slug', squad)
+    .maybeSingle();
+
+  const payload = {
+    workspace_id: workspaceId,
+    squad_id: squadRecord?.id || null,
+    squad_slug: squad,
+    run_id: runId,
+    status: state?.status || 'unknown',
+    state: state || {},
+    source_path: normalizePath(runDir),
+    started_at: state?.startedAt || null,
+    completed_at: state?.completedAt || null,
+    failed_at: state?.failedAt || null,
+  };
+  const { data, error } = await client
+    .from('os_runs')
+    .upsert(payload, { onConflict: 'workspace_id,squad_slug,run_id' })
+    .select()
+    .single();
+
+  if (error) throw new Error(`Unable to upsert run: ${formatSupabaseError({ error })}`);
+  return data;
+}
+
+async function insertStateSnapshot(client, workspaceId, runUuid, squad, runId, statePath, state) {
+  const payload = {
+    workspace_id: workspaceId,
+    run_uuid: runUuid,
+    squad_slug: squad,
+    run_id: runId,
+    status: state.status || 'unknown',
+    step: state.step || null,
+    state,
+    state_hash: hashText(JSON.stringify(state)),
+    source_path: normalizePath(statePath),
+  };
+  const { error } = await client.from('os_run_state_snapshots').insert(payload);
+  if (error) throw new Error(`Unable to insert state snapshot: ${formatSupabaseError({ error })}`);
+}
+
+async function upsertArtifacts(client, workspaceId, runUuid, squad, runId, artifacts) {
+  if (artifacts.length === 0) return;
+  const rows = artifacts.map((artifact) => ({
+    workspace_id: workspaceId,
+    run_uuid: runUuid,
+    squad_slug: squad,
+    run_id: runId,
+    relative_path: artifact.path,
+    artifact_type: artifact.type,
+    mime_type: artifact.mimeType,
+    byte_size: artifact.byteSize,
+    content_hash: artifact.hash,
+    storage_bucket: null,
+    storage_path: null,
+    metadata: artifact.metadata,
+  }));
+  const { error } = await client.from('os_artifacts').upsert(rows, { onConflict: 'workspace_id,relative_path,content_hash' });
+  if (error) throw new Error(`Unable to upsert artifacts: ${formatSupabaseError({ error })}`);
+}
+
+async function insertEvent(client, workspaceId, eventType, payload, runUuid = null) {
+  const { error } = await client.from('os_events').insert({
+    workspace_id: workspaceId,
+    run_uuid: runUuid,
+    event_type: eventType,
+    payload,
+  });
+  if (error) throw new Error(`Unable to insert event: ${formatSupabaseError({ error })}`);
+}
+
+async function buildInventory(targetDir) {
+  const skills = [];
+  const squads = [];
+  const memoryFiles = [];
+
+  for (const skillDir of await listDirectories(join(targetDir, 'skills'))) {
+    const skillPath = join(targetDir, 'skills', skillDir, 'SKILL.md');
+    const file = await readTextFile(skillPath);
+    if (!file) continue;
+    skills.push({
+      slug: skillDir,
+      path: normalizePath(relative(targetDir, skillPath)),
+      content: file.content,
+      byteSize: file.byteSize,
+      hash: hashText(file.content),
+      frontmatter: parseFrontmatter(file.content),
+    });
+  }
+
+  for (const squadDir of await listDirectories(join(targetDir, 'squads'))) {
+    const squadPath = join(targetDir, 'squads', squadDir, 'squad.yaml');
+    const file = await readTextFile(squadPath);
+    if (!file) continue;
+    squads.push({
+      slug: squadDir,
+      name: extractYamlScalar(file.content, 'name') || extractYamlScalar(file.content, 'displayName') || squadDir,
+      path: normalizePath(relative(targetDir, squadPath)),
+      content: file.content,
+      byteSize: file.byteSize,
+      hash: hashText(file.content),
+    });
+  }
+
+  for (const memoryPath of [
+    join(targetDir, '_opensquad', '_memory', 'company.md'),
+    join(targetDir, '_opensquad', '_memory', 'preferences.md'),
+    join(targetDir, '_opensquad', '_memory', 'brands.md'),
+  ]) {
+    const file = await readTextFile(memoryPath);
+    if (!file) continue;
+    memoryFiles.push({
+      path: normalizePath(relative(targetDir, memoryPath)),
+      byteSize: file.byteSize,
+      hash: hashText(file.content),
+      preview: file.content.slice(0, 500),
+    });
+  }
+
+  return { skills, squads, memoryFiles };
+}
+
+async function collectArtifacts(targetDir, runDir, options = {}) {
+  const files = await listFiles(runDir);
+  const artifacts = [];
+  for (const filePath of files) {
+    const info = await stat(filePath);
+    if (options.limitBytes > 0 && info.size > options.limitBytes) {
+      artifacts.push({
+        path: normalizePath(relative(targetDir, filePath)),
+        type: 'file',
+        mimeType: guessMimeType(filePath),
+        byteSize: info.size,
+        hash: null,
+        metadata: { hashSkipped: true, reason: 'larger_than_limit' },
+      });
+      continue;
+    }
+    const content = await readFile(filePath);
+    artifacts.push({
+      path: normalizePath(relative(targetDir, filePath)),
+      type: artifactType(filePath),
+      mimeType: guessMimeType(filePath),
+      byteSize: info.size,
+      hash: hashBuffer(content),
+      metadata: {},
+    });
+  }
+  return artifacts;
+}
+
+async function findRunDir(targetDir, squad, runId) {
+  const candidates = [
+    join(targetDir, 'squads', squad, 'output', runId),
+    join(targetDir, 'squads', squad, 'output', 'archive', runId),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const info = await stat(candidate);
+      if (info.isDirectory()) return candidate;
+    } catch {
+      // Try next candidate
+    }
+  }
+  return null;
+}
+
+async function listDirectories(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+async function listFiles(dir) {
+  const files = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+async function readTextFile(path) {
+  try {
+    const content = await readFile(path, 'utf-8');
+    return { content, byteSize: Buffer.byteLength(content) };
+  } catch {
+    return null;
+  }
+}
+
+async function readJsonFile(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export async function loadEnv(targetDir = process.cwd()) {
+  const env = { ...process.env };
+  try {
+    const raw = await readFile(join(targetDir, '.env'), 'utf-8');
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const separatorIndex = trimmed.indexOf('=');
+      if (separatorIndex === -1) continue;
+      const key = trimmed.slice(0, separatorIndex).trim();
+      const value = trimmed.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+      if (key && !(key in env)) env[key] = value;
+    }
+  } catch {
+    // Optional .env
+  }
+  return env;
+}
+
+function parseFlags(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const next = args[index + 1];
+    if (!next || next.startsWith('--')) {
+      flags[key] = true;
+    } else {
+      flags[key] = next;
+      index += 1;
+    }
+  }
+  return flags;
+}
+
+function parseFrontmatter(content) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result = {};
+  for (const line of match[1].split('\n')) {
+    const item = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!item) continue;
+    const value = item[2].trim();
+    if (value && value !== '>' && value !== '|') result[item[1]] = stripQuotes(value);
+  }
+  return result;
+}
+
+function extractYamlScalar(content, key) {
+  const match = content.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+  return match ? stripQuotes(match[1].trim()) : null;
+}
+
+function stripQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, '');
+}
+
+function hashText(content) {
+  return hashBuffer(Buffer.from(content));
+}
+
+function hashBuffer(buffer) {
+  return createHash('sha256').update(buffer).digest('hex');
+}
+
+function normalizePath(path) {
+  return path.replace(/\\/g, '/');
+}
+
+function guessMimeType(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith('.json')) return 'application/json';
+  if (lower.endsWith('.md')) return 'text/markdown';
+  if (lower.endsWith('.html')) return 'text/html';
+  if (lower.endsWith('.txt')) return 'text/plain';
+  if (lower.endsWith('.csv')) return 'text/csv';
+  if (lower.endsWith('.png')) return 'image/png';
+  if (lower.endsWith('.jpg') || lower.endsWith('.jpeg')) return 'image/jpeg';
+  if (lower.endsWith('.mp4')) return 'video/mp4';
+  if (lower.endsWith('.mp3')) return 'audio/mpeg';
+  if (lower.endsWith('.pdf')) return 'application/pdf';
+  return 'application/octet-stream';
+}
+
+function artifactType(path) {
+  const mimeType = guessMimeType(path);
+  if (mimeType.startsWith('image/')) return 'image';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType.startsWith('audio/')) return 'audio';
+  if (mimeType === 'text/html') return 'dashboard';
+  if (mimeType === 'application/json' || mimeType.startsWith('text/')) return 'text';
+  return 'file';
+}
+
+function printChecks(checks) {
+  for (const [name, ok, note] of checks) {
+    const status = ok ? 'OK' : 'MISSING';
+    console.log(`  ${status.padEnd(7)} ${name}${note ? ` — ${note}` : ''}`);
+  }
+}
+
+function isOk(result) {
+  return !result?.error && (result?.status == null || result.status < 400);
+}
+
+function formatSupabaseError(result) {
+  const error = result?.error;
+  if (!error) return result?.statusText || '';
+  if (typeof error === 'string') return error;
+  const parts = [];
+  if (error.code) parts.push(error.code);
+  if (error.message) parts.push(error.message);
+  if (error.details) parts.push(error.details);
+  if (error.hint) parts.push(`hint: ${error.hint}`);
+  if (parts.length > 0) return parts.join(' — ');
+  if (result?.status || result?.statusText) {
+    return `${result.status || ''} ${result.statusText || ''}`.trim();
+  }
+  return JSON.stringify(error);
+}
+
+function printInventory(inventory) {
+  console.log(`  Skills: ${inventory.skills.length}`);
+  console.log(`  Squads: ${inventory.squads.length}`);
+  console.log(`  Memory files: ${inventory.memoryFiles.length}`);
+  if (inventory.squads.length > 0) {
+    console.log(`  Squad slugs: ${inventory.squads.map((squad) => squad.slug).join(', ')}`);
+  }
+}