@ctrl-spc/cs 0.1.0 → 0.2.0

package/dist/codebases.js

@@ -0,0 +1,108 @@
+import { hostedRemoteIdentity } from './git-remote.js';
+/** Raised when a folder's git remote isn't a real hosted repository URL, so it
+ *  can't become a codebase. The route surfaces it as a 400 refusal. */
+export class NotHostedRemoteError extends Error {
+    constructor(message = "This folder's git remote isn't a hosted repository URL, so it can't become a codebase.") {
+        super(message);
+        this.name = 'NotHostedRemoteError';
+    }
+}
+/**
+ * The codebases registered on one project.
+ *
+ * Rows live in the isolated `cliv2_codebases` table (org-scoped RLS mirroring
+ * `public.projects`, so this returns every codebase on the project — a codebase
+ * is shared project state visible to every member of the project's org, not a
+ * per-user list). `project_id` references a shared `projects` row by value with
+ * no FK — the v2 surface stays decoupled from v1-owned schema. Only path-free
+ * identities (canonical remote + derived name) are stored, never an absolute
+ * local path (each user's local folder path stays in the CLI's local config).
+ */
+export async function listCodebases(client, projectId) {
+    const { data, error } = await client
+        .from('cliv2_codebases')
+        .select('id, git_remote_url, name')
+        .eq('project_id', projectId)
+        .order('created_at', { ascending: true });
+    if (error)
+        throw new Error(error.message);
+    return (data ?? []).map((row) => ({
+        id: row.id,
+        gitRemoteUrl: row.git_remote_url,
+        name: row.name,
+    }));
+}
+/**
+ * A display name from a canonical `host/path` remote: its last `/` segment.
+ * E.g. `github.com/acme/web` → `web`. Throws rather than ever returning an
+ * empty name (the table's `name` column is `not null`, non-blank).
+ */
+export function deriveCodebaseName(identity) {
+    const name = identity.split('/').pop()?.trim() ?? '';
+    if (!name)
+        throw new Error(`Could not derive a codebase name from "${identity}".`);
+    return name;
+}
+/**
+ * Add a codebase to a project by its git remote URL. The raw remote is
+ * canonicalized to `host/path` (stripping scheme, credentials, `.git`, trailing
+ * slash) BEFORE insert, so only a path-free, shareable identity reaches the
+ * cloud and the unique dedupe key actually holds ("same remote = same
+ * codebase"). A remote that isn't a real hosted repo is refused
+ * (NotHostedRemoteError) and never inserted. `added_by` defaults to auth.uid().
+ *
+ * Returns `{ added: false }` on a unique-violation — the dedupe key is now
+ * (project_id, git_remote_url), so this fires when ANY org member has already
+ * added this remote to the project — a no-op dedupe, never surfaced as an error.
+ */
+export async function addCodebase(client, projectId, gitRemoteUrl) {
+    const identity = hostedRemoteIdentity(gitRemoteUrl);
+    if (!identity)
+        throw new NotHostedRemoteError();
+    const name = deriveCodebaseName(identity);
+    const { error } = await client
+        .from('cliv2_codebases')
+        .insert({ project_id: projectId, git_remote_url: identity, name });
+    if (error) {
+        if (error.code === '23505')
+            return { added: false }; // dedupe: already on the project
+        throw new Error(error.message);
+    }
+    return { added: true };
+}
+/**
+ * Remove a codebase from its project — Phase 3. Deletes the ORG-SHARED
+ * `cliv2_codebases` row by id, so the codebase disappears for every member of
+ * the project's org (its RLS `using` = org membership, so any member may delete;
+ * no extra scoping needed here).
+ *
+ * Deliberately narrow: this deletes ONLY the codebase row. It does NOT touch
+ * per-machine availability (`cliv2_codebase_locations`) or the local folder
+ * mapping (`codebase-paths.json`) — those are per-repo truth, kept so a later
+ * re-add of the same remote shows this computer located again for free.
+ */
+export async function removeCodebase(client, codebaseId) {
+    const { error } = await client.from('cliv2_codebases').delete().eq('id', codebaseId);
+    if (error)
+        throw new Error(error.message);
+}
+/**
+ * Record that THIS machine has a codebase's folder checked out — Phase 2
+ * per-machine availability. Upserts one path-free row into the owner-scoped
+ * `cliv2_codebase_locations` table on `(user_id, machine_id, git_remote_url)`,
+ * refreshing `updated_at`. `user_id` defaults to `auth.uid()` server-side — the
+ * client never sets it — and RLS confines the row to the signed-in user's own
+ * machines (a user's availability is private, mirroring `cliv2_agents`).
+ *
+ * `identity` MUST already be a canonical `host/path` remote (the caller
+ * re-derives it from the folder via `hostedRemoteIdentity`). An absolute local
+ * path is NEVER sent — only the identity + this machine's id, honoring the
+ * product's path-privacy invariant.
+ */
+export async function reportLocated(client, machineId, identity) {
+    const { error } = await client
+        .from('cliv2_codebase_locations')
+        .upsert({ machine_id: machineId, git_remote_url: identity, updated_at: new Date().toISOString() }, { onConflict: 'user_id,machine_id,git_remote_url' });
+    if (error)
+        throw new Error(error.message);
+}