@gaia-ai/addon-remote-drupal 0.6.5 → 0.8.0

package/dist/src/index.d.ts

@@ -23,17 +23,30 @@ export declare class DrupalGaiaRemote implements GaiaRemote {
     closeTicket(uuid: string): Promise<void>;
     markTicketCleanedUp(uuid: string): Promise<void>;
     /**
-     * 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
+     * UUID + absolute worktree path of the ticket's latest run (highest run id
+     * with a non-empty worktree_path), or empty strings when none — the cwd the
+     * cleanup command runs in, plus the record its teardown is noted on
+     * (GAIA-293). The conductor persists worktree_path on markRunning, so a done
      * ticket's run carries the path even after the run closed.
+     *
+     * The uuid rides along on the query that already resolves the path, so the
+     * reaper learns which run to write to at no extra round-trip.
      */
-    private latestRunWorktree;
+    private latestRun;
+    appendRunNote(runUuid: string, note: string): Promise<void>;
     resolveTicketByIdentifier(project: string, identifier: string): Promise<{
         uuid: string;
         title: string;
     } | null>;
     private readonly projectUuidCache;
+    /**
+     * The project *name* behind a project uuid — the inverse of projectUuid.
+     *
+     * A conductor row references its project; the CLI and the cockpit want to
+     * show the name. Best-effort: an unreadable project must not fail a listing,
+     * so it degrades to '' and the row still renders.
+     */
+    private projectName;
     private projectUuid;
 }
 export declare function drupalRemote(): RemotePlugin;

package/dist/src/index.js

@@ -1,8 +1,4 @@
-// GAIA-224 (Finding 6, decision 8): the Drupal control-plane remote — formerly
-// `@gaia-ai/core`'s `plugins/remote/drupal.ts`, now its own conductor-surface
-// addon. Core ships no plugin implementations; every mountable lives under
-// `addons/*`. The surface contract comes from `@gaia-ai/conductor/contract`
-// (runtime-light: types + the tiny selectors, no engine).
+import { toUnixSeconds } from '@gaia-ai/core';
 import { resolveAuth } from 'dropsh';
 import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
 const ACTIVE = ['claimed', 'running'];
@@ -16,6 +12,22 @@ const ACTIVE = ['claimed', 'running'];
  * change, since it asks the workflow definition directly.
  */
 const TERMINAL = ['done', 'cancelled'];
+/**
+ * The process-identity attributes a registration carries, if any (GAIA-232).
+ *
+ * Spread rather than assigned so an absent value sends no key at all: the
+ * server treats a missing key as "leave the stored value alone", which is what
+ * lets `poll` and `reap` heartbeat past a running conductor without wiping the
+ * pid it needs to be stoppable.
+ */
+function processIdentity(reg) {
+    return {
+        ...(reg.last_pid === undefined ? {} : { last_pid: reg.last_pid }),
+        ...(reg.conductor_name === undefined
+            ? {}
+            : { conductor_name: reg.conductor_name }),
+    };
+}
 export class DrupalGaiaRemote {
     api;
     constructor(api) {
@@ -156,6 +168,7 @@ export class DrupalGaiaRemote {
                 label: reg.label,
                 states: reg.states,
                 max_parallel: reg.max_parallel,
+                ...processIdentity(reg),
             },
             relationships: {
                 owner_user_id: {
@@ -186,6 +199,7 @@ export class DrupalGaiaRemote {
                     max_parallel: reg.max_parallel,
                     current_load: load,
                     lease_seconds: lease,
+                    ...processIdentity(reg),
                 },
             },
         }));
@@ -215,14 +229,38 @@ export class DrupalGaiaRemote {
             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,
-        }));
+        // Resolve each distinct project once rather than per row: a machine
+        // typically runs several conductors of the same project.
+        const projectNames = new Map();
+        for (const r of rows) {
+            const uuid = r.rel('project_id');
+            if (uuid && !projectNames.has(uuid)) {
+                projectNames.set(uuid, await this.projectName(uuid));
+            }
+        }
+        return rows.map((r) => {
+            // Spread the optionals conditionally: an absent field must be absent,
+            // not present-and-undefined (exactOptionalPropertyTypes), and a row
+            // written before GAIA-232 legitimately carries neither.
+            const pid = r.attr('last_pid');
+            const name = r.attr('conductor_name');
+            return {
+                id: r.attr('machine_id') ?? r.id,
+                project: projectNames.get(r.rel('project_id') ?? '') ?? '',
+                label: r.attr('label') ?? '',
+                status: r.attr('status') ?? '',
+                // ISO-8601 over the wire, not the unix integer the field name implies.
+                lastSeen: toUnixSeconds(r.attr('last_seen')) ?? 0,
+                load: r.attr('current_load') ?? 0,
+                workspaceRoot: r.attr('workspace_root') ?? '',
+                leaseExpiresAt: toUnixSeconds(r.attr('lease_expires_at')) ?? 0,
+                maxParallel: r.attr('max_parallel') ?? 0,
+                ...(typeof pid === 'number' ? { lastPid: pid } : {}),
+                ...(typeof name === 'string' && name !== ''
+                    ? { conductorName: name }
+                    : {}),
+            };
+        });
     }
     async markRunning(uuid, attrs) {
         const t = Math.floor(Date.now() / 1000);
@@ -317,7 +355,7 @@ export class DrupalGaiaRemote {
             branchName: r.attr('branch_name') ?? '',
             state: r.attr('state') ?? '',
             closed: r.attr('closed') ?? false,
-            worktreePath: await this.latestRunWorktree(r.id),
+            ...(await this.latestRun(r.id)),
         })));
     }
     async closeTicket(uuid) {
@@ -332,12 +370,16 @@ export class DrupalGaiaRemote {
         }); // 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
+     * UUID + absolute worktree path of the ticket's latest run (highest run id
+     * with a non-empty worktree_path), or empty strings when none — the cwd the
+     * cleanup command runs in, plus the record its teardown is noted on
+     * (GAIA-293). The conductor persists worktree_path on markRunning, so a done
      * ticket's run carries the path even after the run closed.
+     *
+     * The uuid rides along on the query that already resolves the path, so the
+     * reaper learns which run to write to at no extra round-trip.
      */
-    async latestRunWorktree(ticketUuid) {
+    async latestRun(ticketUuid) {
         const rows = await this.api
             .collection('gaia_run')
             .where('ticket_id.id', '=', ticketUuid)
@@ -348,10 +390,45 @@ export class DrupalGaiaRemote {
         for (const r of rows) {
             const path = r.attr('worktree_path');
             if (path) {
-                return path;
+                return { runUuid: r.id, worktreePath: path };
             }
         }
-        return '';
+        return { runUuid: '', worktreePath: '' };
+    }
+    async appendRunNote(runUuid, note) {
+        if (!runUuid) {
+            return; // no run to record anything on
+        }
+        // Read `log` ALONE, through the sparse fieldset every neighbouring query in
+        // this file uses. A note append has no business pulling the run's
+        // relationships and its dozen other attributes, and `log` is already the
+        // heaviest field on the row.
+        const run = await this.api
+            .collection('gaia_run')
+            .where('id', '=', runUuid)
+            .fields(['log'])
+            .first();
+        if (!run) {
+            // Refuse rather than guess. With no row read, `existing` below would be ''
+            // and the PATCH would REPLACE the transcript with this one diagnostic
+            // line — destroying exactly what the note exists to preserve. An
+            // unreadable run is the reaper's best-effort catch (it warns and still
+            // flags the ticket), never a silent truncation.
+            throw new Error(`gaia_run ${runUuid} could not be read — run note not written`);
+        }
+        // `log` is a `text_long` field, so JSON:API sends it as
+        // `{ value, format, processed }` — not a bare string. Reading it through an
+        // `attr<string>` cast cannot fail at runtime, it just yields the object, and
+        // interpolating that wrote the literal `[object Object]` over the run's
+        // transcript. Read the main property, and keep accepting a plain string so a
+        // backend (or a double) handing one back still appends correctly.
+        const raw = run.attr('log');
+        const existing = typeof raw === 'string'
+            ? raw
+            : (raw?.value ?? '');
+        await this.api.update('gaia_run', runUuid, {
+            attributes: { log: existing ? `${existing}\n${note}` : note },
+        }); // NO state/closed — the run is already closed.
     }
     async resolveTicketByIdentifier(project, identifier) {
         // Scope by the project uuid: identifiers (GAIA-nnn) are unique per project,
@@ -369,6 +446,22 @@ export class DrupalGaiaRemote {
         return { uuid: t.id, title: t.attr('title') ?? '' };
     }
     projectUuidCache = new Map();
+    /**
+     * The project *name* behind a project uuid — the inverse of projectUuid.
+     *
+     * A conductor row references its project; the CLI and the cockpit want to
+     * show the name. Best-effort: an unreadable project must not fail a listing,
+     * so it degrades to '' and the row still renders.
+     */
+    async projectName(uuid) {
+        try {
+            const p = await this.api.resource('gaia_project', uuid);
+            return p.attr('name') ?? '';
+        }
+        catch {
+            return '';
+        }
+    }
     async projectUuid(name) {
         // A project's name→uuid never changes, so cache it: gatherBatch resolves
         // many identifiers per `gaia deployment tickets` call, each of which would

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-remote-drupal",
-  "version": "0.6.5",
+  "version": "0.8.0",
   "description": "GAIA conductor remote addon: the Drupal/JSON:API control-plane remote.",
   "type": "module",
   "license": "MIT",
@@ -23,7 +23,7 @@
     "dropsh": "^0.5.8"
   },
   "peerDependencies": {
-    "@gaia-ai/conductor": "^0.6.5",
-    "@gaia-ai/core": "^0.6.5"
+    "@gaia-ai/conductor": "^0.8.0",
+    "@gaia-ai/core": "^0.8.0"
   }
 }