@gaia-ai/core 0.4.0

package/dist/src/plugins/remote/drupal.js

@@ -0,0 +1,363 @@
+import { resolveAuth } from 'dropsh';
+import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
+const ACTIVE = ['claimed', 'running'];
+/**
+ * Extracts gaia_comment resources from a JSON:API `included` array into
+ * conductor-facing TicketComments. JSON:API renames the comment entity's `type`
+ * field to `gaia_comment_type` (the bare `type` is the reserved resource type),
+ * and serialises the text_long `body` as `{value, format, processed}`. Resources
+ * of other types are ignored; the server already returns them created-ASC.
+ */
+export function parseTicketComments(included) {
+    if (!Array.isArray(included)) {
+        return [];
+    }
+    const comments = [];
+    for (const res of included) {
+        if (res?.type !== 'gaia_comment--gaia_comment') {
+            continue;
+        }
+        const attrs = res.attributes ?? {};
+        const body = attrs.body;
+        const value = typeof body === 'string'
+            ? body
+            : typeof body?.value === 'string'
+                ? body.value
+                : '';
+        comments.push({
+            type: typeof attrs.gaia_comment_type === 'string'
+                ? attrs.gaia_comment_type
+                : 'comment',
+            body: value,
+            created: typeof attrs.created === 'string' ? attrs.created : '',
+        });
+    }
+    return comments;
+}
+export class DrupalGaiaRemote {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async fetchActiveRuns(id) {
+        // The conductor identity `id` is the machine_id (hash of hostname+path).
+        // gaia_run links to its owning conductor via the `conductor_id` entity-ref;
+        // filter on the related conductor's `machine_id` (nested relationship filter).
+        const rows = await this.api
+            .collection('gaia_run')
+            .where('conductor_id.machine_id', '=', id)
+            .whereIn('state', ACTIVE)
+            .fields(['state', 'state_at_start', 'worktree_path'])
+            .page(100)
+            .list();
+        return Promise.all(rows.map(async (r) => ({
+            runUuid: r.id,
+            ticketUuid: r.rel('ticket_id') ?? '',
+            ticketIdentifier: await this.getRunTicketIdentifier(r.id),
+            branchName: await this.getRunTicketBranchName(r.id),
+            state: r.attr('state') ?? '',
+            stateAtStart: r.attr('state_at_start') ?? '',
+            worktreePath: r.attr('worktree_path') ?? '',
+        })));
+    }
+    async activeRunCount(id) {
+        // Filter on the related conductor's `machine_id` (nested relationship filter).
+        return this.api
+            .collection('gaia_run')
+            .where('conductor_id.machine_id', '=', id)
+            .whereIn('state', ACTIVE)
+            .fields(['drupal_internal__id'])
+            .page(100)
+            .count();
+    }
+    async claimNext(c) {
+        const res = (await this.api.post('gaia/claim-next', {
+            data: {
+                attributes: {
+                    lease_seconds: c.leaseSeconds,
+                    // Server (`ConductorResolverTrait`) narrows to the caller's conductor
+                    // by the `machine_id` attribute; `c.conductorId` IS the machine_id.
+                    machine_id: c.conductorId,
+                },
+            },
+        }));
+        if (!res?.data) {
+            return null;
+        }
+        const d = res.data;
+        const rawId = d.attributes?.drupal_internal__id;
+        if (rawId === undefined || rawId === null) {
+            throw new Error(`claimNext: missing drupal_internal__id on run ${d.id}`);
+        }
+        return {
+            runUuid: d.id,
+            runId: Number(rawId),
+            ticketUuid: d.relationships?.ticket_id?.data?.id ?? '',
+            stateAtStart: String(d.attributes?.state_at_start ?? ''),
+            // handler_id was dropped; the handler is the work the run does, i.e. the
+            // ticket state the run started in.
+            handler: String(d.attributes?.state_at_start ?? ''),
+        };
+    }
+    async getTicket(uuid) {
+        // `?include=comments` sideloads the ticket's comments in one request so the
+        // conductor can render them into the dispatch prompt (review→coding bounce
+        // must carry the review summary to the coder). `comments` is a computed
+        // entity_reference field (CommentsItemList, ordered created ASC), so the
+        // included resources arrive oldest-first. We use the raw client here rather
+        // than `resource()` because `resource()` discards the `included` array.
+        const doc = (await this.api.get(`gaia_ticket/gaia_ticket/${uuid}?include=comments`));
+        const attrs = doc.data?.attributes ?? {};
+        const issueUrl = typeof attrs.origin === 'string' ? attrs.origin : undefined;
+        return {
+            uuid: doc.data?.id ?? uuid,
+            identifier: typeof attrs.identifier === 'string' ? attrs.identifier : uuid,
+            title: typeof attrs.title === 'string' ? attrs.title : '',
+            state: typeof attrs.state === 'string' ? attrs.state : '',
+            branchName: typeof attrs.branch_name === 'string' ? attrs.branch_name : '',
+            ...(typeof attrs.base_branch === 'string' && attrs.base_branch !== ''
+                ? { baseBranch: attrs.base_branch }
+                : {}),
+            ...(typeof attrs.effective_env_vars === 'string' &&
+                attrs.effective_env_vars !== ''
+                ? { effectiveEnvVars: attrs.effective_env_vars }
+                : {}),
+            comments: parseTicketComments(doc.included),
+            ...(issueUrl ? { issueUrl } : {}),
+        };
+    }
+    async getRunWorktree(uuid) {
+        const r = await this.api.resource('gaia_run', uuid);
+        return r.attr('worktree_path') ?? '';
+    }
+    async getRunTicketIdentifier(uuid) {
+        const run = await this.api.resource('gaia_run', uuid);
+        const ticketUuid = run.rel('ticket_id');
+        if (!ticketUuid) {
+            return '';
+        }
+        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
+        return ticket.attr('identifier') ?? '';
+    }
+    async getRunTicketBranchName(uuid) {
+        const run = await this.api.resource('gaia_run', uuid);
+        const ticketUuid = run.rel('ticket_id');
+        if (!ticketUuid) {
+            return '';
+        }
+        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
+        return ticket.attr('branch_name') ?? '';
+    }
+    async registerConductor(reg) {
+        const r = await this.api.upsert('gaia_conductor', { path: 'machine_id', value: reg.id }, {
+            attributes: {
+                machine_id: reg.id,
+                status: 'online',
+                workspace_root: reg.workspace,
+                label: reg.label,
+                states: reg.states,
+                max_parallel: reg.max_parallel,
+            },
+            relationships: {
+                owner_user_id: {
+                    data: { type: 'user--user', id: await this.api.me() },
+                },
+                project_id: {
+                    data: {
+                        type: 'gaia_project--gaia_project',
+                        id: await this.projectUuid(reg.project),
+                    },
+                },
+            },
+        });
+        return r.id; // drupal uuid
+    }
+    async heartbeat(reg, load, lease = 300) {
+        // Server-side upsert by machine_id (see HeartbeatResource): never 404s,
+        // heals a vanished registration, and returns the resulting status. Sending
+        // the full registration lets the server recreate the entity when missing.
+        const res = (await this.api.post('gaia/heartbeat', {
+            data: {
+                attributes: {
+                    machine_id: reg.id,
+                    project: reg.project,
+                    states: reg.states,
+                    workspace_root: reg.workspace,
+                    label: reg.label,
+                    max_parallel: reg.max_parallel,
+                    current_load: load,
+                    lease_seconds: lease,
+                },
+            },
+        }));
+        const status = res?.data?.attributes?.status;
+        return typeof status === 'string' ? status : 'online';
+    }
+    async getConductorStatus(id) {
+        const c = await this.api
+            .collection('gaia_conductor')
+            .where('machine_id', '=', id)
+            .fields(['status'])
+            .first();
+        return c ? (c.attr('status') ?? null) : null;
+    }
+    async setConductorStatus(id, status) {
+        const c = await this.api
+            .collection('gaia_conductor')
+            .where('machine_id', '=', id)
+            .first();
+        if (c) {
+            await this.api.update('gaia_conductor', c.id, { attributes: { status } });
+        }
+    }
+    async listConductors(owner) {
+        let col = this.api.collection('gaia_conductor');
+        if (owner === 'me') {
+            col = col.where('owner_user_id.id', '=', await this.api.me());
+        }
+        const rows = await col.page(200).list();
+        return rows.map((r) => ({
+            id: r.attr('machine_id') ?? r.id,
+            project: '',
+            label: r.attr('label') ?? '',
+            status: r.attr('status') ?? '',
+            lastSeen: r.attr('last_seen') ?? 0,
+            load: r.attr('current_load') ?? 0,
+        }));
+    }
+    async markRunning(uuid, attrs) {
+        const t = Math.floor(Date.now() / 1000);
+        await this.api.update('gaia_run', uuid, {
+            attributes: {
+                state: 'running',
+                heartbeat: t,
+                ...(attrs?.worktree_path ? { worktree_path: attrs.worktree_path } : {}),
+            },
+        });
+    }
+    async fetchFinalizableRuns(id) {
+        const rows = await this.api
+            .collection('gaia_run')
+            .where('conductor_id.machine_id', '=', id)
+            .where('state', '=', 'done')
+            .where('closed', '=', '0')
+            .fields(['worktree_path'])
+            .page(100)
+            .list();
+        return rows.map((r) => ({
+            runUuid: r.id,
+            worktreePath: r.attr('worktree_path') ?? '',
+        }));
+    }
+    async finalizeRun(uuid, log) {
+        const t = Math.floor(Date.now() / 1000);
+        await this.api.update('gaia_run', uuid, {
+            attributes: {
+                closed: true,
+                closed_date: t,
+                ...(log ? { log } : {}),
+            },
+        }); // NO state — the run is already done.
+    }
+    async fetchUncleanedTickets() {
+        // Finished tickets whose worktree is not yet torn down (cleaned_up=0),
+        // driven by the durable `cleaned_up` flag (GAIA-89). "Finished" = reached
+        // `done` OR already `closed`; the collection builder has no OR, so this is
+        // two AND-queries merged + de-duped by uuid. NOT machine-scoped, so the
+        // same query backs both the tick and the standalone `gaia conductor reap`
+        // and catches tickets orphaned while a conductor was down / after a restart
+        // / after a `conductor_id` reassignment (RC2/RC3).
+        const fields = ['branch_name', 'state', 'closed'];
+        const done = await this.api
+            .collection('gaia_ticket')
+            .where('state', '=', 'done')
+            .where('cleaned_up', '=', '0')
+            .fields(fields)
+            .page(100)
+            .list();
+        const closed = await this.api
+            .collection('gaia_ticket')
+            .where('closed', '=', '1')
+            .where('cleaned_up', '=', '0')
+            .fields(fields)
+            .page(100)
+            .list();
+        const byUuid = new Map();
+        for (const r of [...done, ...closed]) {
+            byUuid.set(r.id, r);
+        }
+        return Promise.all([...byUuid.values()].map(async (r) => ({
+            ticketUuid: r.id,
+            branchName: r.attr('branch_name') ?? '',
+            state: r.attr('state') ?? '',
+            closed: r.attr('closed') ?? false,
+            worktreePath: await this.latestRunWorktree(r.id),
+        })));
+    }
+    async closeTicket(uuid) {
+        const t = Math.floor(Date.now() / 1000);
+        await this.api.update('gaia_ticket', uuid, {
+            attributes: { closed: true, closed_date: t },
+        }); // NO state — the ticket is already done.
+    }
+    async markTicketCleanedUp(uuid) {
+        await this.api.update('gaia_ticket', uuid, {
+            attributes: { cleaned_up: true },
+        }); // NO state/closed — teardown flag only, decoupled from the lifecycle.
+    }
+    /**
+     * Absolute worktree path of the ticket's latest run (highest run id with a
+     * non-empty worktree_path), or '' when none — the cwd the cleanup command
+     * runs in. The conductor persists worktree_path on markRunning, so a done
+     * ticket's run carries the path even after the run closed.
+     */
+    async latestRunWorktree(ticketUuid) {
+        const rows = await this.api
+            .collection('gaia_run')
+            .where('ticket_id.id', '=', ticketUuid)
+            .fields(['worktree_path', 'drupal_internal__id'])
+            .sort('-drupal_internal__id')
+            .page(100)
+            .list();
+        for (const r of rows) {
+            const path = r.attr('worktree_path');
+            if (path) {
+                return path;
+            }
+        }
+        return '';
+    }
+    async projectUuid(name) {
+        const p = await this.api
+            .collection('gaia_project')
+            .where('name', '=', name)
+            .first();
+        if (!p) {
+            throw new Error(`gaia project "${name}" not found`);
+        }
+        return p.id;
+    }
+}
+export function drupalRemote() {
+    return {
+        kind: 'remote',
+        id: 'drupal',
+        requiredModules: [],
+        async createRemote(config) {
+            const http = createHttpClient();
+            const auth = await resolveAuth({
+                baseUrl: config.site.base_url,
+                plugins: config.plugins ?? [],
+                http,
+                now: Date.now,
+                // stateDir omitted → dropsh defaultStateDir() (~/.config/dropsh)
+            });
+            return new DrupalGaiaRemote(createJsonApiClient({
+                baseUrl: config.site.base_url,
+                prefix: config.site.jsonapi_prefix,
+                http,
+                auth: auth,
+            }));
+        },
+    };
+}

package/dist/src/plugins/remote/fake.d.ts

@@ -0,0 +1,87 @@
+import type { RemotePlugin } from '../plugins.js';
+import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunWriteAttributes, Ticket, TicketComment, UncleanTicket } from './remote.js';
+export interface FakeSeedRun {
+    runUuid: string;
+    /** Numeric (drupal_internal__id) run id. Defaults to a stable 1-based counter when omitted. */
+    id?: number;
+    ticketUuid: string;
+    stateAtStart: string;
+    /** Override the initial state (defaults to stateAtStart). */
+    state?: string;
+    handler?: string;
+    worktreePath?: string;
+    closed?: boolean;
+}
+export interface FakeSeedTicket {
+    identifier: string;
+    title: string;
+    state: string;
+    branchName?: string;
+    /** Computed base branch (parent branch / project default / 'main'). */
+    baseBranch?: string;
+    /** Effective env vars (parent-chain resolved) as `.env`-style lines. */
+    effectiveEnvVars?: string;
+    url?: string;
+    workflow?: string;
+    comments?: TicketComment[];
+    /** Whether the ticket is already closed (its lifecycle wound up). */
+    closed?: boolean;
+    /** Whether the ticket's worktree is already torn down (cleaned_up flag). */
+    cleanedUp?: boolean;
+}
+export interface FakeRemoteSeed {
+    runs?: FakeSeedRun[];
+    tickets?: Record<string, FakeSeedTicket>;
+}
+export interface MarkRunningCall {
+    runUuid: string;
+    attrs?: {
+        worktree_path?: string;
+    };
+}
+export interface FinalizeRunCall {
+    runUuid: string;
+    log: string;
+}
+export declare class FakeGaiaRemote implements GaiaRemote {
+    readonly calls: {
+        markRunning: MarkRunningCall[];
+        finalizeRun: FinalizeRunCall[];
+        closeTicket: string[];
+        markCleanedUp: string[];
+    };
+    /**
+     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
+     * list verbatim instead of deriving it from the internal runs map.
+     */
+    activeRuns: ActiveRun[] | null;
+    private readonly runs;
+    private readonly queue;
+    private readonly tickets;
+    private conductorStatus;
+    /** Stable counter for assigning numeric ids to unseeded runs. */
+    private runIdCounter;
+    constructor(seed?: FakeRemoteSeed);
+    registerConductor(_reg: ConductorRegistration): Promise<string>;
+    heartbeat(): Promise<string>;
+    getConductorStatus(_conductorId: string): Promise<string | null>;
+    setConductorStatus(_conductorId: string, status: 'offline' | 'online'): Promise<void>;
+    listConductors(_owner?: 'me'): Promise<ConductorStatus[]>;
+    activeRunCount(_conductorId: string): Promise<number>;
+    fetchActiveRuns(_conductorId: string): Promise<ActiveRun[]>;
+    claimNext(_claim: ClaimOptions): Promise<ClaimedRun | null>;
+    getTicket(ticketUuid: string): Promise<Ticket>;
+    getRunWorktree(runUuid: string): Promise<string>;
+    getRunTicketIdentifier(runUuid: string): Promise<string>;
+    getRunTicketBranchName(runUuid: string): Promise<string>;
+    markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
+    fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
+    finalizeRun(runUuid: string, log: string): Promise<void>;
+    fetchUncleanedTickets(): Promise<UncleanTicket[]>;
+    closeTicket(uuid: string): Promise<void>;
+    markTicketCleanedUp(uuid: string): Promise<void>;
+    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
+    private latestRunWorktree;
+    private internalActiveRuns;
+}
+export declare function fakeRemote(seed?: FakeRemoteSeed): RemotePlugin;

package/dist/src/plugins/remote/fake.js

@@ -0,0 +1,214 @@
+const ACTIVE = ['claimed', 'running'];
+export class FakeGaiaRemote {
+    calls = {
+        markRunning: [],
+        finalizeRun: [],
+        closeTicket: [],
+        markCleanedUp: [],
+    };
+    /**
+     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
+     * list verbatim instead of deriving it from the internal runs map.
+     */
+    activeRuns = null;
+    runs = new Map();
+    queue = [];
+    tickets;
+    conductorStatus = 'online';
+    /** Stable counter for assigning numeric ids to unseeded runs. */
+    runIdCounter = 0;
+    constructor(seed = {}) {
+        this.tickets = seed.tickets ?? {};
+        for (const r of seed.runs ?? []) {
+            const handler = r.handler ?? 'code';
+            // Use the seeded id when provided; otherwise assign a deterministic counter.
+            const runId = r.id ?? ++this.runIdCounter;
+            this.runs.set(r.runUuid, {
+                runUuid: r.runUuid,
+                runId,
+                ticketUuid: r.ticketUuid,
+                handler,
+                state: r.state ?? r.stateAtStart,
+                stateAtStart: r.stateAtStart,
+                ...(r.worktreePath !== undefined
+                    ? { worktreePath: r.worktreePath }
+                    : {}),
+                ...(r.closed !== undefined ? { closed: r.closed } : {}),
+            });
+            this.queue.push({
+                runUuid: r.runUuid,
+                runId,
+                ticketUuid: r.ticketUuid,
+                stateAtStart: r.stateAtStart,
+                handler,
+            });
+        }
+    }
+    async registerConductor(_reg) {
+        this.conductorStatus = 'online';
+        return 'fake-conductor-uuid';
+    }
+    async heartbeat() {
+        // Mirrors the server: a heartbeat always brings the conductor online.
+        this.conductorStatus = 'online';
+        return this.conductorStatus;
+    }
+    async getConductorStatus(_conductorId) {
+        return this.conductorStatus;
+    }
+    async setConductorStatus(_conductorId, status) {
+        this.conductorStatus = status;
+    }
+    async listConductors(_owner) {
+        return [];
+    }
+    async activeRunCount(_conductorId) {
+        return this.internalActiveRuns().length;
+    }
+    async fetchActiveRuns(_conductorId) {
+        if (this.activeRuns !== null) {
+            return this.activeRuns;
+        }
+        return this.internalActiveRuns().map((r) => {
+            const ticket = this.tickets[r.ticketUuid];
+            const identifier = ticket?.identifier ?? '';
+            const branchName = ticket?.branchName ??
+                (identifier ? `gaia/${identifier.toLowerCase()}` : '');
+            return {
+                runUuid: r.runUuid,
+                ticketUuid: r.ticketUuid,
+                ticketIdentifier: identifier,
+                branchName,
+                state: r.state,
+                stateAtStart: r.stateAtStart,
+                worktreePath: r.worktreePath ?? '',
+            };
+        });
+    }
+    async claimNext(_claim) {
+        return this.queue.shift() ?? null;
+    }
+    async getTicket(ticketUuid) {
+        const t = this.tickets[ticketUuid];
+        if (!t) {
+            throw new Error(`fake remote: ticket ${ticketUuid} not seeded`);
+        }
+        const branchName = t.branchName ?? `gaia/${t.identifier.toLowerCase()}`;
+        return {
+            uuid: ticketUuid,
+            identifier: t.identifier,
+            title: t.title,
+            state: t.state,
+            branchName,
+            ...(t.baseBranch ? { baseBranch: t.baseBranch } : {}),
+            ...(t.effectiveEnvVars ? { effectiveEnvVars: t.effectiveEnvVars } : {}),
+            comments: t.comments ?? [],
+            ...(t.url ? { issueUrl: t.url } : {}),
+        };
+    }
+    async getRunWorktree(runUuid) {
+        return this.runs.get(runUuid)?.worktreePath ?? '';
+    }
+    async getRunTicketIdentifier(runUuid) {
+        const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
+        if (!ticketUuid) {
+            return '';
+        }
+        return this.tickets[ticketUuid]?.identifier ?? '';
+    }
+    async getRunTicketBranchName(runUuid) {
+        const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
+        if (!ticketUuid) {
+            return '';
+        }
+        const ticket = this.tickets[ticketUuid];
+        if (!ticket) {
+            return '';
+        }
+        return ticket.branchName ?? `gaia/${ticket.identifier.toLowerCase()}`;
+    }
+    async markRunning(runUuid, attrs) {
+        this.calls.markRunning.push({
+            runUuid,
+            ...(attrs
+                ? {
+                    attrs: {
+                        ...(attrs.worktree_path
+                            ? { worktree_path: attrs.worktree_path }
+                            : {}),
+                    },
+                }
+                : {}),
+        });
+        const run = this.runs.get(runUuid);
+        if (run) {
+            run.state = 'running';
+            if (attrs?.worktree_path) {
+                run.worktreePath = attrs.worktree_path;
+            }
+        }
+    }
+    async fetchFinalizableRuns(_conductorId) {
+        return [...this.runs.values()]
+            .filter((r) => r.state === 'done' && !r.closed)
+            .map((r) => ({ runUuid: r.runUuid, worktreePath: r.worktreePath ?? '' }));
+    }
+    async finalizeRun(runUuid, log) {
+        this.calls.finalizeRun.push({ runUuid, log });
+        const run = this.runs.get(runUuid);
+        if (run) {
+            run.closed = true;
+            if (log)
+                run.log = log;
+        }
+    }
+    async fetchUncleanedTickets() {
+        return Object.entries(this.tickets)
+            .filter(([, t]) => (t.state === 'done' || t.closed) && !t.cleanedUp)
+            .map(([ticketUuid, t]) => ({
+            ticketUuid,
+            branchName: t.branchName ?? `gaia/${t.identifier.toLowerCase()}`,
+            worktreePath: this.latestRunWorktree(ticketUuid),
+            state: t.state,
+            closed: t.closed ?? false,
+        }));
+    }
+    async closeTicket(uuid) {
+        this.calls.closeTicket.push(uuid);
+        const t = this.tickets[uuid];
+        if (t) {
+            t.closed = true;
+        }
+    }
+    async markTicketCleanedUp(uuid) {
+        this.calls.markCleanedUp.push(uuid);
+        const t = this.tickets[uuid];
+        if (t) {
+            t.cleanedUp = true;
+        }
+    }
+    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
+    latestRunWorktree(ticketUuid) {
+        let worktree = '';
+        for (const r of this.runs.values()) {
+            if (r.ticketUuid === ticketUuid && r.worktreePath) {
+                worktree = r.worktreePath;
+            }
+        }
+        return worktree;
+    }
+    internalActiveRuns() {
+        return [...this.runs.values()].filter((r) => ACTIVE.includes(r.state));
+    }
+}
+export function fakeRemote(seed = {}) {
+    const remote = new FakeGaiaRemote(seed);
+    return {
+        kind: 'remote',
+        id: 'fake',
+        requiredModules: [],
+        async createRemote(_config) {
+            return remote;
+        },
+    };
+}