@youtyan/code-viewer 0.6.7 → 0.6.9

package/README.md

@@ -34,6 +34,8 @@ Requires Node.js 20 or newer when installed from npm. Development uses
   viewer.
 - Browse SQLite, PostgreSQL, MySQL, Redis, Elasticsearch, and S3-compatible
   object storage (MinIO, LocalStack) with a built-in datastore viewer.
+  Local Supabase CLI (`supabase start`) Postgres projects are auto-discovered
+  too, without needing a `docker-compose.yml`.
 - Read the built-in Help page for getting started, the `.code-viewer/`
   project files, AI annotations, datastores, the agent skill, and
   keybindings.
@@ -42,8 +44,9 @@ Requires Node.js 20 or newer when installed from npm. Development uses
   `@youtyan/code-viewer` version and execution origin (npx cache vs
   local), SQLite driver and snapshot store, Git, discovery summary,
   per-source datastore connectivity (each discovered SQLite / docker
-  SQL / Redis / Elasticsearch / S3 source gets one row with a 2s
-  minimal-read probe; failure rows include a paste-safe retry hint),
+  SQL / Supabase CLI / Redis / Elasticsearch / S3 source gets one row
+  with a 2s minimal-read probe; failure rows include a paste-safe retry
+  hint),
   Docker / Compose health (config dry-parse + `compose ps` per service),
   and the listening port. Useful when `npx` cache mismatch (e.g.
   `NODE_MODULE_VERSION` errors) needs a remediation hint, or when a
@@ -178,7 +181,10 @@ separate project-level config file). `.DS_Store` and a broad set of
 build/cache directories (`node_modules`, `dist`, `build`, `.next`, `.turbo`,
 `.parcel-cache`, `.vite`, `.angular`, `.dart_tool`, `.venv`, …) are hidden by
 default. Pass `--scope-omit-dir <name>` (repeatable) to override the omit
-list on the command line for one session.
+list on the command line for one session. `.devbox` and `.direnv` are always
+excluded regardless of saved settings or CLI overrides: they hold thousands
+of generated directories (Nix store link trees) that would stall the
+worktree watcher.
 
 The viewer keeps its per-project state under `.code-viewer/` at the repository
 root:
@@ -216,6 +222,15 @@ Services whose names collide across subdirectories are kept distinct via
 `docker:<service>@<relDir>` ids (cwd-direct compose files keep the historical
 `docker:<service>` id for backward compatibility).
 
+**Supabase CLI** (`supabase start`) local projects are also auto-discovered,
+even though the Supabase CLI does not write a `docker-compose.yml` into the
+project directory. Any `supabase/config.toml` found by the same recursive scan
+is picked up (`project_id` and `[db] port` are read from it), and the running
+Postgres container is resolved directly via `docker ps` (matched by container
+name and the `com.supabase.cli.project` label) instead of `docker compose ps`.
+Connection defaults to the Supabase CLI's documented local credentials
+(`postgres`/`postgres`/`postgres`).
+
 **Redis** support: browse DB 0–15, SCAN keys, and view values per
 type (string/hash/list as dedicated panes, set/zset/stream as JSON views).
 Edit values, delete keys, and create new keys (string/hash/list/set/zset/stream)

package/dist/code-viewer.js

@@ -1052,6 +1052,10 @@ function normalizeBlameRef(ref, base) {
   }
   return { base, ref: rawRef };
 }
+function withAlwaysWorktreeOmitDirNames(names) {
+  const missing = ALWAYS_WORKTREE_OMIT_DIR_NAMES.filter((name) => !names.includes(name));
+  return missing.length ? [...names, ...missing] : names;
+}
 function run(args, cwd) {
   return runSync(resolveGitArgs(args), cwd, {
     timeout: GIT_COMMAND_TIMEOUT_MS
@@ -2118,10 +2122,11 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
+var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200;
 var init_git = __esm(() => {
   init_command_resolver();
   init_runtime();
+  ALWAYS_WORKTREE_OMIT_DIR_NAMES = [".devbox", ".direnv"];
   DEFAULT_WORKTREE_OMIT_DIR_NAMES = [
     "node_modules",
     "bower_components",
@@ -2142,8 +2147,7 @@ var init_git = __esm(() => {
     "out",
     "target",
     ".gradle",
-    ".devbox",
-    ".direnv",
+    ...ALWAYS_WORKTREE_OMIT_DIR_NAMES,
     ".pnpm-store",
     ".turbo",
     ".parcel-cache",
@@ -9608,7 +9612,7 @@ var init_spawn_runner = () => {};
 // web-src/server/database/adapters/docker-utils.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function isDockerComposeServiceUnavailableError(err) {
-  return err instanceof DockerComposeServiceUnavailableError || err instanceof DockerCommandUnavailableError;
+  return err instanceof DockerComposeServiceUnavailableError || err instanceof DockerCommandUnavailableError || err instanceof SupabaseDbContainerUnavailableError;
 }
 function dockerCommand() {
   return commandForExternal("docker");
@@ -9625,10 +9629,15 @@ function throwIfCachedComposeDockerCommandUnavailable(cwd) {
   const failure = composePsCache.get(cwd)?.error || "";
   throwIfDockerCommandUnavailableResult({ code: 1, stderr: failure });
 }
-function parseComposePsOutput(stdout) {
+function parseDockerJsonLines(stdout) {
   const output = stdout.trim();
-  const containers = output.startsWith("[") ? JSON.parse(output) : output.split(`
+  if (!output)
+    return [];
+  return output.startsWith("[") ? JSON.parse(output) : output.split(`
 `).filter(Boolean).map((line) => JSON.parse(line));
+}
+function parseComposePsOutput(stdout) {
+  const containers = parseDockerJsonLines(stdout);
   const byService = new Map;
   for (const container of containers) {
     if (container.Service && container.Name && container.State === "running") {
@@ -9647,15 +9656,14 @@ function cacheComposePsFailure(cwd, result, now) {
     error: stderr
   });
 }
-function runComposePsAsync(cwd, signal) {
-  throwIfAborted(signal, "docker compose ps aborted");
+function runDockerCliAsync(args, opts) {
+  throwIfAborted(opts.signal, opts.abortMessage);
   if (spawnSyncImpl !== spawnSync2) {
-    const command = dockerCommand();
-    const proc = spawnSyncImpl(command, ["compose", "ps", "--format", "json", "--status", "running"], {
+    const proc = spawnSyncImpl(dockerCommand(), args, {
       encoding: "utf8",
       timeout: 5000,
       stdio: ["ignore", "pipe", "pipe"],
-      cwd
+      ...opts.cwd ? { cwd: opts.cwd } : {}
     });
     return Promise.resolve({
       stdout: String(proc.stdout || ""),
@@ -9666,16 +9674,24 @@ ${proc.error.message}` : ""}`,
   }
   return spawnTextAsync({
     command: dockerCommand(),
-    args: ["compose", "ps", "--format", "json", "--status", "running"],
-    cwd,
+    args,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
     timeoutMs: 5000,
-    signal,
+    signal: opts.signal,
     killSignal: "SIGKILL",
-    abortMessage: "docker compose ps aborted",
-    timeoutMessage: "docker compose ps timed out",
+    abortMessage: opts.abortMessage,
+    timeoutMessage: opts.timeoutMessage,
     rejectOnError: false
   });
 }
+function runComposePsAsync(cwd, signal) {
+  return runDockerCliAsync(["compose", "ps", "--format", "json", "--status", "running"], {
+    cwd,
+    signal,
+    abortMessage: "docker compose ps aborted",
+    timeoutMessage: "docker compose ps timed out"
+  });
+}
 async function resolveRunningComposeContainerNameAsync(serviceName, cwd, signal) {
   throwIfAborted(signal, "docker compose ps aborted");
   const now = Date.now();
@@ -9773,7 +9789,128 @@ async function resolveRunningComposeContainerNameOrThrowAsync(serviceName, cwd,
   }
   return containerName;
 }
-var COMPOSE_CONTAINER_NAME_POSITIVE_TTL_MS = 30000, COMPOSE_CONTAINER_NAME_NEGATIVE_TTL_MS = 3000, COMPOSE_PS_FAILURE_TTL_MS = 15000, composePsCache, composePsPending, spawnSyncImpl, DockerComposeServiceUnavailableError, DockerCommandUnavailableError;
+function supabaseDbContainerName(projectId) {
+  return `supabase_db_${projectId}`;
+}
+function parseDockerPsOutput(stdout) {
+  return parseDockerJsonLines(stdout);
+}
+function runDockerPsAsync(args, signal) {
+  return runDockerCliAsync(args, {
+    signal,
+    abortMessage: "docker ps aborted",
+    timeoutMessage: "docker ps timed out"
+  });
+}
+async function resolveRunningSupabaseDbContainerAsync(projectId, signal) {
+  throwIfAborted(signal, "docker ps aborted");
+  const containerName = supabaseDbContainerName(projectId);
+  const now = Date.now();
+  const cached = supabaseContainerCache.get(projectId);
+  if (cached) {
+    if (cached.containerName && cached.positiveExpiresAt > now) {
+      return cached.containerName;
+    }
+    if (!cached.containerName && cached.negativeExpiresAt > now) {
+      return null;
+    }
+  }
+  let pending = supabaseContainerPending.get(projectId);
+  if (!pending) {
+    const controller = new AbortController;
+    pending = {
+      controller,
+      refs: 0,
+      done: false,
+      promise: (async () => {
+        const startedAt = Date.now();
+        const cacheMiss = (negativeTtlMs) => {
+          supabaseContainerCache.set(projectId, {
+            containerName: null,
+            positiveExpiresAt: startedAt,
+            negativeExpiresAt: startedAt + negativeTtlMs
+          });
+          return null;
+        };
+        let proc;
+        try {
+          proc = await runDockerPsAsync([
+            "ps",
+            "--filter",
+            `name=^/${containerName}$`,
+            "--filter",
+            `label=com.supabase.cli.project=${projectId}`,
+            "--filter",
+            "status=running",
+            "--format",
+            "json"
+          ], controller.signal);
+        } catch (err) {
+          if (isAbortLikeError(err, controller.signal))
+            throw err;
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        if (proc.code !== 0) {
+          throwIfDockerCommandUnavailableResult(proc);
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        let containers;
+        try {
+          containers = parseDockerPsOutput(proc.stdout);
+        } catch {
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        }
+        const match = containers.some((c) => (c.Names || "").replace(/^\//, "") === containerName);
+        if (!match)
+          return cacheMiss(SUPABASE_CONTAINER_NEGATIVE_TTL_MS);
+        supabaseContainerCache.set(projectId, {
+          containerName,
+          positiveExpiresAt: startedAt + SUPABASE_CONTAINER_POSITIVE_TTL_MS,
+          negativeExpiresAt: startedAt
+        });
+        return containerName;
+      })().finally(() => {
+        if (supabaseContainerPending.get(projectId) === pending) {
+          supabaseContainerPending.delete(projectId);
+        }
+        if (pending)
+          pending.done = true;
+      })
+    };
+    supabaseContainerPending.set(projectId, pending);
+  }
+  pending.refs++;
+  let released = false;
+  const release = () => {
+    if (released)
+      return;
+    released = true;
+    pending.refs--;
+    if (pending.refs <= 0 && !pending.done) {
+      pending.controller.abort();
+    }
+  };
+  signal?.addEventListener("abort", release, { once: true });
+  if (signal?.aborted) {
+    signal.removeEventListener("abort", release);
+    release();
+    throwIfAborted(signal, "docker ps aborted");
+  }
+  try {
+    return await pending.promise;
+  } finally {
+    signal?.removeEventListener("abort", release);
+    release();
+  }
+}
+async function resolveRunningSupabaseDbContainerOrThrowAsync(projectId, signal) {
+  const containerName = await resolveRunningSupabaseDbContainerAsync(projectId, signal);
+  if (!containerName) {
+    throw new SupabaseDbContainerUnavailableError(projectId);
+  }
+  return containerName;
+}
+var COMPOSE_CONTAINER_NAME_POSITIVE_TTL_MS = 30000, COMPOSE_CONTAINER_NAME_NEGATIVE_TTL_MS = 3000, COMPOSE_PS_FAILURE_TTL_MS = 15000, composePsCache, composePsPending, spawnSyncImpl, DockerComposeServiceUnavailableError, DockerCommandUnavailableError, SupabaseDbContainerUnavailableError, SUPABASE_CONTAINER_POSITIVE_TTL_MS = 15000, SUPABASE_CONTAINER_NEGATIVE_TTL_MS = 3000, supabaseContainerCache, supabaseContainerPending;
 var init_docker_utils = __esm(() => {
   init_command_resolver();
   init_spawn_runner();
@@ -9798,6 +9935,17 @@ var init_docker_utils = __esm(() => {
       this.name = "DockerCommandUnavailableError";
     }
   };
+  SupabaseDbContainerUnavailableError = class SupabaseDbContainerUnavailableError extends Error {
+    projectId;
+    status = 503;
+    constructor(projectId) {
+      super(`Supabase local DB container for project "${projectId}" is not running. Start it with: supabase start`);
+      this.name = "SupabaseDbContainerUnavailableError";
+      this.projectId = projectId;
+    }
+  };
+  supabaseContainerCache = new Map;
+  supabaseContainerPending = new Map;
 });
 
 // web-src/server/database/adapters/sql-capture.ts
@@ -10670,13 +10818,9 @@ async function listDockerSchemasAsync(serviceName, kind, env, cwd, overrideDatab
     throwIfCachedComposeDockerCommandUnavailable(cwd);
     return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
-  const config = {
-    kind,
-    containerName,
-    user,
-    password,
-    database
-  };
+  return fetchPostgresSchemasViaContainerAsync({ kind, containerName, user, password, database }, cacheKey, now, signal);
+}
+async function fetchPostgresSchemasViaContainerAsync(config, cacheKey, now, signal) {
   try {
     const sql = `SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema') AND schema_name NOT LIKE 'pg_toast%' AND schema_name NOT LIKE 'pg_temp_%' AND schema_name NOT LIKE 'pg_toast_temp_%' AND has_schema_privilege(schema_name, 'USAGE') ORDER BY CASE WHEN schema_name = 'public' THEN 0 ELSE 1 END, schema_name`;
     const result = await execInContainerAsync(config, sql, 1e4, signal);
@@ -10695,6 +10839,38 @@ async function listDockerSchemasAsync(serviceName, kind, env, cwd, overrideDatab
     return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
 }
+function supabaseSchemasCacheKey(projectId) {
+  return `supabase\x00${projectId}`;
+}
+async function listSupabaseSchemasAsync(projectId, signal) {
+  const cacheKey = supabaseSchemasCacheKey(projectId);
+  const now = Date.now();
+  const cached = dockerSchemasCache.get(cacheKey);
+  if (cached && cached.expiresAt > now)
+    return [...cached.value];
+  const containerName = await resolveRunningSupabaseDbContainerAsync(projectId, signal);
+  if (!containerName) {
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+  return fetchPostgresSchemasViaContainerAsync({
+    kind: "postgresql",
+    containerName,
+    user: SUPABASE_LOCAL_DB_USER,
+    password: SUPABASE_LOCAL_DB_PASSWORD,
+    database: SUPABASE_LOCAL_DB_NAME
+  }, cacheKey, now, signal);
+}
+async function openSupabaseDockerAdapterAsync(projectId, schema, signal) {
+  const containerName = await resolveRunningSupabaseDbContainerOrThrowAsync(projectId, signal);
+  return createDockerAdapter({
+    kind: "postgresql",
+    containerName,
+    user: SUPABASE_LOCAL_DB_USER,
+    password: SUPABASE_LOCAL_DB_PASSWORD,
+    database: SUPABASE_LOCAL_DB_NAME,
+    ...schema ? { schema } : {}
+  });
+}
 async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatabase, schema, signal) {
   const containerName = await resolveRunningComposeContainerNameOrThrowAsync(serviceName, cwd, signal);
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
@@ -10709,7 +10885,7 @@ async function openDockerAdapterAsync(serviceName, kind, env, cwd, overrideDatab
     ...kind === "postgresql" && schema ? { schema } : {}
   });
 }
-var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES;
+var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, PG_RECORD_SEPARATOR = "\x1E", MYSQL_SPATIAL_TYPES, SUPABASE_LOCAL_DB_USER = "postgres", SUPABASE_LOCAL_DB_PASSWORD = "postgres", SUPABASE_LOCAL_DB_NAME = "postgres";
 var init_docker = __esm(() => {
   init_mutate();
   init_sql_snapshot();
@@ -13595,6 +13771,39 @@ async function pathExistsAsync(path) {
     return false;
   }
 }
+async function walkForMarkerFileAsync(dir, depth, omitSet, hasCapacity, visitDir, signal) {
+  if (signal?.aborted || !hasCapacity())
+    return;
+  if (depth > MAX_SCAN_DEPTH)
+    return;
+  await visitDir(dir);
+  if (signal?.aborted || !hasCapacity())
+    return;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (signal?.aborted || !hasCapacity())
+      return;
+    if (omitSet.has(entry.toLowerCase()))
+      continue;
+    const full = join8(dir, entry);
+    let entryStat;
+    try {
+      entryStat = await lstat(full);
+    } catch {
+      continue;
+    }
+    if (entryStat.isSymbolicLink())
+      continue;
+    if (entryStat.isDirectory()) {
+      await walkForMarkerFileAsync(full, depth + 1, omitSet, hasCapacity, visitDir, signal);
+    }
+  }
+}
 async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   const cacheKey = dockerDiscoveryCacheKey(cwd, omitDirNames);
   const now = Date.now();
@@ -13606,13 +13815,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
   const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
   omitSet.add(".git");
   omitSet.add("node_modules");
-  async function scan(dir, depth) {
-    if (signal?.aborted)
-      return;
-    if (results.length >= MAX_DOCKER_SERVICES)
-      return;
-    if (depth > MAX_SCAN_DEPTH)
-      return;
+  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_DOCKER_SERVICES, async (dir) => {
     for (const filename of COMPOSE_FILENAMES) {
       const filepath = join8(dir, filename);
       if (await pathExistsAsync(filepath)) {
@@ -13620,37 +13823,7 @@ async function discoverDockerDatabasesAsync(cwd, omitDirNames = [], signal) {
         break;
       }
     }
-    if (signal?.aborted)
-      return;
-    if (results.length >= MAX_DOCKER_SERVICES)
-      return;
-    let entries;
-    try {
-      entries = await readdir(dir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (signal?.aborted)
-        return;
-      if (results.length >= MAX_DOCKER_SERVICES)
-        return;
-      if (omitSet.has(entry.toLowerCase()))
-        continue;
-      const full = join8(dir, entry);
-      let entryStat;
-      try {
-        entryStat = await lstat(full);
-      } catch {
-        continue;
-      }
-      if (entryStat.isSymbolicLink())
-        continue;
-      if (entryStat.isDirectory())
-        await scan(full, depth + 1);
-    }
-  }
-  await scan(cwd, 0);
+  }, signal);
   if (signal?.aborted)
     return cloneDockerDiscoveryResult(results);
   if (results.length >= MAX_DOCKER_SERVICES) {
@@ -13745,7 +13918,120 @@ function isSafeDockerDatabaseName(value) {
     return false;
   return /^[A-Za-z0-9_$.-]+$/.test(value);
 }
-var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache;
+function cloneSupabaseDiscoveryResult(result) {
+  return result.map((entry) => ({ ...entry }));
+}
+function parseSupabaseConfigToml(content) {
+  let section = null;
+  let projectId = null;
+  let dbPort = null;
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1];
+      continue;
+    }
+    const kvMatch = line.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.+)$/);
+    if (!kvMatch)
+      continue;
+    const value = stripScalarSyntax(kvMatch[2]);
+    if (section === null && kvMatch[1] === "project_id") {
+      projectId = value;
+    } else if (section === "db" && kvMatch[1] === "port") {
+      dbPort = value;
+    }
+  }
+  if (!projectId || !isSafeDockerServiceName(projectId))
+    return null;
+  return {
+    projectId,
+    dbPort: dbPort && /^\d+$/.test(dbPort) ? dbPort : DEFAULT_SUPABASE_DB_PORT
+  };
+}
+async function discoverSupabaseCliProjectsAsync(cwd, omitDirNames = [], signal) {
+  const cacheKey = discoveryCacheKey(cwd, omitDirNames);
+  const now = Date.now();
+  const cached = supabaseDiscoveryCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return cloneSupabaseDiscoveryResult(cached.result);
+  }
+  const omitSet = new Set(omitDirNames.map((d) => d.toLowerCase()));
+  omitSet.add(".git");
+  omitSet.add("node_modules");
+  const results = [];
+  await walkForMarkerFileAsync(cwd, 0, omitSet, () => results.length < MAX_SUPABASE_PROJECTS, async (dir) => {
+    const configPath = join8(dir, "supabase", "config.toml");
+    if (!await pathExistsAsync(configPath))
+      return;
+    try {
+      const content = await readFile2(configPath, "utf-8");
+      const parsed = parseSupabaseConfigToml(content);
+      if (!parsed)
+        return;
+      const relDir = relative3(cwd, dir);
+      const isRoot = relDir === "" || relDir === ".";
+      const relDirSlash = relDir.replace(/\\/g, "/");
+      const id = isRoot ? `supabase:${parsed.projectId}` : `supabase:${parsed.projectId}@${encodeURIComponent(relDirSlash)}`;
+      const labelPath = isRoot ? "" : ` — ${relDirSlash}`;
+      results.push({
+        id,
+        path: isRoot ? "supabase/config.toml" : `${relDirSlash}/supabase/config.toml`,
+        name: `${parsed.projectId} (Supabase CLI, postgres@127.0.0.1:${parsed.dbPort}/postgres${labelPath})`,
+        sizeBytes: 0,
+        kind: "postgresql",
+        projectId: parsed.projectId,
+        relDirSlash,
+        dbPort: parsed.dbPort
+      });
+    } catch {}
+  }, signal);
+  if (signal?.aborted)
+    return cloneSupabaseDiscoveryResult(results);
+  supabaseDiscoveryCache.set(cacheKey, {
+    expiresAt: now + SUPABASE_DISCOVERY_TTL_MS,
+    result: cloneSupabaseDiscoveryResult(results)
+  });
+  return cloneSupabaseDiscoveryResult(results);
+}
+function parseSupabaseDbId(dbId) {
+  if (!dbId.startsWith("supabase:"))
+    return null;
+  const rest = dbId.slice("supabase:".length);
+  if (!rest)
+    return null;
+  const atIdx = rest.indexOf("@");
+  let projectId;
+  let relDir = "";
+  if (atIdx >= 0) {
+    if (rest.indexOf("@", atIdx + 1) >= 0)
+      return null;
+    projectId = rest.slice(0, atIdx);
+    try {
+      relDir = decodeURIComponent(rest.slice(atIdx + 1));
+    } catch {
+      return null;
+    }
+    if (!isSafeDockerRelDir(relDir))
+      return null;
+  } else {
+    projectId = rest;
+  }
+  if (!isSafeDockerServiceName(projectId))
+    return null;
+  return { projectId, relDir };
+}
+async function findSupabaseCliProjectByDbIdAsync(cwd, dbId, omitDirNames, signal) {
+  const parsed = parseSupabaseDbId(dbId);
+  if (!parsed)
+    return null;
+  const projects = await discoverSupabaseCliProjectsAsync(cwd, omitDirNames, signal);
+  return projects.find((p) => p.projectId === parsed.projectId && p.relDirSlash === parsed.relDir) || null;
+}
+var SQLITE_EXTENSIONS, SQLITE_MAGIC = "SQLite format 3\x00", MAX_SCAN_DEPTH = 3, MAX_ENTRIES = 50, DOCKER_DISCOVERY_TTL_MS = 5000, SQLITE_DISCOVERY_TTL_MS = 5000, sqliteDiscoveryCache, COMPOSE_FILENAMES, MAX_DOCKER_SERVICES = 30, dockerDiscoveryCache, MAX_SUPABASE_PROJECTS = 30, SUPABASE_DISCOVERY_TTL_MS = 5000, DEFAULT_SUPABASE_DB_PORT = "54322", supabaseDiscoveryCache;
 var init_discovery = __esm(() => {
   SQLITE_EXTENSIONS = new Set([".db", ".sqlite", ".sqlite3", ".s3db"]);
   sqliteDiscoveryCache = new Map;
@@ -13756,6 +14042,7 @@ var init_discovery = __esm(() => {
     "compose.yaml"
   ];
   dockerDiscoveryCache = new Map;
+  supabaseDiscoveryCache = new Map;
 });
 
 // web-src/core/id.ts
@@ -16750,8 +17037,9 @@ function sanitizeCssSize(v) {
   return isValidCssSize(v) ? v : undefined;
 }
 function isToolInternalDbId(dbId) {
-  if (!dbId || dbId.startsWith("docker:"))
+  if (!dbId || dbId.startsWith("docker:") || dbId.startsWith("supabase:")) {
     return false;
+  }
   return dbId.split(/[\\/]+/).some((part) => part.toLowerCase() === ".code-viewer");
 }
 function sanitizeRedis(v) {
@@ -16930,6 +17218,11 @@ async function getAdapter(r, _cwd, signal) {
     const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
     return dockerAdapterCache.getOrOpenAsync(cacheKey, () => openDockerAdapterAsync(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database, r.schema, signal));
   }
+  if (r.supabase) {
+    const projectId = r.supabase.projectId;
+    const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
+    return dockerAdapterCache.getOrOpenAsync(cacheKey, () => openSupabaseDockerAdapterAsync(projectId, r.schema, signal));
+  }
   return getConnection(r.resolved);
 }
 function sanitizeFilename(name) {
@@ -16956,9 +17249,35 @@ async function resolvePostgresSchema(info, requestedSchema, signal) {
     return "public";
   return schemas[0] || "public";
 }
+async function resolveSupabaseSchema(info, requestedSchema, signal) {
+  if (requestedSchema)
+    return requestedSchema;
+  const schemas = await listSupabaseSchemasAsync(info.projectId, signal);
+  if (schemas.includes("public"))
+    return "public";
+  return schemas[0] || "public";
+}
 async function resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal) {
   if (!dbParam)
     return textError("missing db parameter", 400);
+  if (dbParam.startsWith("supabase:")) {
+    const parsed = parseSupabaseDbId(dbParam);
+    if (!parsed)
+      return textError("invalid supabase db id", 400);
+    const info = await findSupabaseCliProjectByDbIdAsync(cwd, dbParam, omitDirNames, signal);
+    if (!info)
+      return textError("supabase project not found", 404);
+    const requestedSchema = normalizeSchemaParam(schemaParam);
+    if (requestedSchema instanceof Response)
+      return requestedSchema;
+    const schema = await resolveSupabaseSchema(info, requestedSchema, signal);
+    return {
+      resolved: dbParam,
+      dbId: dbParam,
+      supabase: info,
+      ...schema ? { schema } : {}
+    };
+  }
   if (dbParam.startsWith("docker:")) {
     const parsed = parseDockerDbId(dbParam);
     if (!parsed)
@@ -17045,17 +17364,22 @@ async function expandDockerServicesForFiles(dockerServices, listDockerDatabases,
 }
 async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_DB_FILE_DISCOVERY_DEPS) {
   ensureInit();
-  const [sqliteSettled, dockerSettled] = await Promise.allSettled([
+  const [sqliteSettled, dockerSettled, supabaseSettled] = await Promise.allSettled([
     deps.discoverSqliteFiles(cwd, omitDirNames, signal),
-    deps.discoverDockerDatabases(cwd, omitDirNames, signal)
+    deps.discoverDockerDatabases(cwd, omitDirNames, signal),
+    deps.discoverSupabaseCliProjects(cwd, omitDirNames, signal)
   ]);
   if (sqliteSettled.status === "rejected") {
     throw sqliteSettled.reason;
   }
+  if (supabaseSettled.status === "rejected") {
+    throw supabaseSettled.reason;
+  }
   if (dockerSettled.status === "rejected" && isAbortLikeError(dockerSettled.reason, signal)) {
     throw dockerSettled.reason;
   }
   const sqliteFiles = sqliteSettled.value;
+  const supabaseProjects = supabaseSettled.value;
   const dockerServices = dockerSettled.status === "fulfilled" ? dockerSettled.value : [];
   const dockerErrors = [];
   if (dockerSettled.status === "rejected") {
@@ -17073,7 +17397,8 @@ async function createDbFilesResponse(cwd, omitDirNames, signal, deps = DEFAULT_D
         sizeBytes: f.sizeBytes,
         kind: "sqlite"
       })),
-      ...dockerEntries.map(toFileInfo)
+      ...dockerEntries.map(toFileInfo),
+      ...supabaseProjects.map(toFileInfo)
     ],
     ...dockerTruncated ? { truncated: true } : {},
     ...dockerErrors.length > 0 ? { dockerError: dockerErrors.join("; ") } : {}
@@ -17087,6 +17412,17 @@ async function createDbSchemasResponse(cwd, dbParam, schemaParam, omitDirNames,
   const r = await resolveDb(cwd, dbParam, omitDirNames, schemaParam, signal);
   if (r instanceof Response)
     return { ok: false, response: r };
+  if (r.supabase) {
+    const projectId = r.supabase.projectId;
+    const { result: schemas2, executedSql: executedSql2 } = await captureSql(() => listSupabaseSchemasAsync(projectId, signal));
+    const body2 = {
+      dbId: r.dbId,
+      schemas: schemas2.map((name) => ({ name })),
+      selectedSchema: r.schema,
+      executedSql: executedSql2
+    };
+    return { ok: true, value: body2 };
+  }
   if (!r.docker || r.docker.kind !== "postgresql") {
     const body2 = { dbId: r.dbId, schemas: [] };
     return { ok: true, value: body2 };
@@ -18128,7 +18464,7 @@ async function handleClose(cwd, req, omitDirNames) {
   const r = await resolveDb(cwd, body.db, omitDirNames, undefined, req.signal);
   if (r instanceof Response)
     return r;
-  if (r.docker) {
+  if (r.docker || r.supabase) {
     dockerAdapterCache.close(r.dbId);
     dockerAdapterCache.closePrefix(`${r.dbId}\x00`);
   } else {
@@ -18343,7 +18679,8 @@ var init_handle = __esm(() => {
   DEFAULT_DB_FILE_DISCOVERY_DEPS = {
     discoverSqliteFiles: discoverSqliteFilesAsync,
     discoverDockerDatabases: discoverDockerDatabasesAsync,
-    listDockerDatabases: listDockerDatabasesAsync
+    listDockerDatabases: listDockerDatabasesAsync,
+    discoverSupabaseCliProjects: discoverSupabaseCliProjectsAsync
   };
   searchJobs = new Map;
   snapshotJobs = new Map;
@@ -19081,6 +19418,9 @@ async function checkDiscovery(cwd, scopeOmitDirNames, signal) {
   };
 }
 async function defaultDatastoreProbe(file, cwd, signal) {
+  if (file.id.startsWith("supabase:")) {
+    return probeSupabaseSource(file, cwd, signal);
+  }
   switch (file.kind) {
     case "sqlite":
       return probeSqliteSource(file, cwd, signal);
@@ -19131,6 +19471,23 @@ async function probeDockerSqlSource(file, cwd, signal) {
     } catch {}
   }
 }
+async function probeSupabaseSource(file, cwd, signal) {
+  const parsed = parseSupabaseDbId(file.id);
+  if (!parsed)
+    throw new Error("invalid supabase db id");
+  const info = await findSupabaseCliProjectByDbIdAsync(cwd, file.id, undefined, signal);
+  if (!info)
+    throw new Error("supabase project not found");
+  const adapter = await openSupabaseDockerAdapterAsync(info.projectId, undefined, signal);
+  try {
+    signal.throwIfAborted();
+    await adapter.getTablesAsync(signal);
+  } finally {
+    try {
+      adapter.close();
+    } catch {}
+  }
+}
 async function probeRedisSource(file, cwd, signal) {
   const info = await findDockerServiceByDbIdAsync(cwd, file.id, "redis", undefined, signal);
   if (!info)
@@ -21730,7 +22087,7 @@ function validateMcpOptionalDbId(raw) {
   const parsed = validateMcpDbId(raw);
   if (parsed.ok !== true)
     return parsed;
-  if (!parsed.value.startsWith("docker:")) {
+  if (!parsed.value.startsWith("docker:") && !parsed.value.startsWith("supabase:")) {
     const pathError = validateMcpPath(parsed.value);
     if (pathError)
       return { ok: false, error: "invalid database path" };
@@ -22164,7 +22521,7 @@ Examples:
   }
   warnIfLegacyConfigPresent();
   if (scopeOmitDirCliOverride) {
-    scopeOmitDirNames = scopeOmitDirCliOverride;
+    scopeOmitDirNames = withAlwaysWorktreeOmitDirNames(scopeOmitDirCliOverride);
   }
   scopeWatchLimit = worktreeWatchDirectoryLimitFromEnv();
 }
@@ -22180,7 +22537,7 @@ function applyPersistedSettings(state) {
   const prevExclude = scopeExcludeNames;
   const prevWatchLimit = scopeWatchLimit;
   if (!scopeOmitDirCliOverride && Array.isArray(state.scopeOmitDirs) && state.scopeOmitDirs.length > 0) {
-    scopeOmitDirNames = state.scopeOmitDirs;
+    scopeOmitDirNames = withAlwaysWorktreeOmitDirNames(state.scopeOmitDirs);
   } else if (!scopeOmitDirCliOverride) {
     scopeOmitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youtyan/code-viewer",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "Local browser-based code and git diff viewer",
   "type": "module",
   "bin": {

package/skills/code-viewer-query/SKILL.md

@@ -39,7 +39,9 @@ browser's Database > Search tab, so the human can review the same workflow.
 1. Discover the datastore ids the running server has detected. This is the
    AI-friendly equivalent of opening the browser's Database tab and reading
    the sidebar — it lists every SQLite file plus PostgreSQL / MySQL / Redis
-   / Elasticsearch / S3 service that any nearby `docker-compose` exposes.
+   / Elasticsearch / S3 service that any nearby `docker-compose` exposes, as
+   well as any local Supabase CLI (`supabase start`) project found via a
+   `supabase/config.toml` (id form `supabase:<project_id>`).
    Use the printed `id` as `--db` on every other command. Credentials and
    internal config are stripped server-side.
 

package/web/app.js

@@ -18724,6 +18724,11 @@ ${entry.message}` : entry.detail ?? entry.message ?? "";
       const service = rest.split(/[@:]/, 1)[0];
       return service || "Docker";
     }
+    if (dbId.startsWith("supabase:")) {
+      const rest = dbId.slice("supabase:".length);
+      const projectId = rest.split(/[@]/, 1)[0];
+      return projectId || "Supabase";
+    }
     const normalized = dbId.replace(/\\/g, "/");
     const lastSlash = normalized.lastIndexOf("/");
     return lastSlash >= 0 ? normalized.slice(lastSlash + 1) : normalized;
@@ -20016,7 +20021,8 @@ ${entry.message}` : entry.detail ?? entry.message ?? "";
         const opt = document.createElement("option");
         opt.value = f2.id;
         const isDocker = f2.id.startsWith("docker:");
-        const label = isDocker ? `${f2.name} (Docker)` : `${f2.path} (${formatSize(f2.sizeBytes)})`;
+        const isSupabase = f2.id.startsWith("supabase:");
+        const label = isDocker ? `${f2.name} (Docker)` : isSupabase ? `${f2.name} (Supabase)` : `${f2.path} (${formatSize(f2.sizeBytes)})`;
         opt.textContent = label;
         optionsFragment.appendChild(opt);
       }
@@ -20206,7 +20212,7 @@ ${entry.message}` : entry.detail ?? entry.message ?? "";
       if (!currentDbInfo)
         return labelFromDbId(initial.dbId);
       const suffix = currentSchema ? ` / ${currentSchema}` : "";
-      if (currentDbInfo.id.startsWith("docker:")) {
+      if (currentDbInfo.id.startsWith("docker:") || currentDbInfo.id.startsWith("supabase:")) {
         const m = currentDbInfo.name.match(/^(\S+)/);
         return `${m ? m[1] : currentDbInfo.name}${suffix}`;
       }
@@ -24709,7 +24715,7 @@ code-viewer annotate add-db --db app.db --tab query \\
                     ],
                     [
                       "PostgreSQL",
-                      "Detected from compose files. Multiple databases per server, plus a schema selector for switching schemas without reopening. Same inline row edit / insert / delete as SQLite."
+                      "Detected from compose files. Multiple databases per server, plus a schema selector for switching schemas without reopening. Same inline row edit / insert / delete as SQLite. Local Supabase CLI (`supabase start`) projects are also auto-discovered from `supabase/config.toml`, without needing a docker-compose file."
                     ],
                     [
                       "Redis",
@@ -25368,7 +25374,7 @@ code-viewer annotate add-db --db app.db --tab query \\
                     ],
                     [
                       "PostgreSQL",
-                      "compose ファイルから検出。同一サーバー上の複数データベースに対応し、スキーマ切替セレクターで再オープンせずスキーマを切り替えられます。SQLite と同じく行のインライン編集 / 追加 / 削除に対応。"
+                      "compose ファイルから検出。同一サーバー上の複数データベースに対応し、スキーマ切替セレクターで再オープンせずスキーマを切り替えられます。SQLite と同じく行のインライン編集 / 追加 / 削除に対応。ローカルの Supabase CLI (`supabase start`) プロジェクトも `supabase/config.toml` から自動検出され、docker-compose ファイルは不要です。"
                     ],
                     [
                       "Redis",