@omercnet/paseo-gas-city 0.1.0

package/server/workspace-mapping.ts

@@ -0,0 +1,170 @@
+import { realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { WorkspaceMappingOverride, WorkspaceRigMapping } from "../shared";
+import { GAS_CITY_LIMITS, WorkspaceRigMappingSchema } from "../shared";
+import type { UpstreamCity, UpstreamRig } from "./gas-city-client";
+
+export interface WorkspaceMappingInput {
+  workspaceId: string;
+  workspacePath: string | null;
+  cities: readonly UpstreamCity[];
+  rigsByCity: ReadonlyMap<string, readonly UpstreamRig[]>;
+  overrides: readonly WorkspaceMappingOverride[];
+  canonicalizePath?: (path: string) => Promise<string>;
+}
+
+async function canonicalPath(path: string): Promise<string> {
+  const absolute = resolve(path);
+  try {
+    return await realpath(absolute);
+  } catch {
+    return absolute;
+  }
+}
+
+function isAncestorPath(ancestor: string, child: string): boolean {
+  const delta = relative(ancestor, child);
+  return delta === "" || (!delta.startsWith(`..${sep}`) && delta !== ".." && !isAbsolute(delta));
+}
+
+function diagnostic(code: string, message: string, retryable: boolean) {
+  return { code, message, retryable };
+}
+
+export async function mapWorkspaceToRig(
+  input: WorkspaceMappingInput,
+): Promise<WorkspaceRigMapping> {
+  const canonicalize = input.canonicalizePath ?? canonicalPath;
+  const explicit = input.overrides.find(({ workspaceId }) => workspaceId === input.workspaceId);
+  if (explicit) {
+    const city = input.cities.find(({ name }) => name === explicit.cityName);
+    const rig = input.rigsByCity
+      .get(explicit.cityName)
+      ?.find(({ name }) => name === explicit.rigName);
+    if (!city || !rig) {
+      return WorkspaceRigMappingSchema.parse({
+        state: "unavailable",
+        workspaceId: input.workspaceId,
+        workspacePath: input.workspacePath,
+        cityName: explicit.cityName,
+        rigName: explicit.rigName,
+        rigPath: null,
+        source: "explicit",
+        candidates: [],
+        diagnostics: [
+          diagnostic(
+            "mapping-target-unavailable",
+            "The explicitly configured Gas City rig is unavailable.",
+            true,
+          ),
+        ],
+      });
+    }
+    return WorkspaceRigMappingSchema.parse({
+      state: "mapped",
+      workspaceId: input.workspaceId,
+      workspacePath: input.workspacePath,
+      cityName: city.name,
+      rigName: rig.name,
+      rigPath: rig.path,
+      source: "explicit",
+      candidates: [{ cityName: city.name, rigName: rig.name, rigPath: rig.path }],
+      diagnostics: [],
+    });
+  }
+
+  if (!input.workspacePath) {
+    return WorkspaceRigMappingSchema.parse({
+      state: "unmapped",
+      workspaceId: input.workspaceId,
+      workspacePath: null,
+      cityName: null,
+      rigName: null,
+      rigPath: null,
+      source: null,
+      candidates: [],
+      diagnostics: [
+        diagnostic("workspace-path-unavailable", "The Paseo workspace has no local path.", false),
+      ],
+    });
+  }
+
+  const workspacePath = await canonicalize(input.workspacePath);
+  const matches: Array<{
+    cityName: string;
+    rigName: string;
+    rigPath: string;
+    canonicalRigPath: string;
+  }> = [];
+  for (const city of input.cities) {
+    for (const rig of input.rigsByCity.get(city.name) ?? []) {
+      const rigPath = await canonicalize(rig.path);
+      if (isAncestorPath(rigPath, workspacePath)) {
+        matches.push({
+          cityName: city.name,
+          rigName: rig.name,
+          rigPath: rig.path,
+          canonicalRigPath: rigPath,
+        });
+      }
+    }
+  }
+  matches.sort(
+    (left, right) =>
+      right.canonicalRigPath.length - left.canonicalRigPath.length ||
+      left.cityName.localeCompare(right.cityName) ||
+      left.rigName.localeCompare(right.rigName),
+  );
+  const candidates = matches.slice(0, GAS_CITY_LIMITS.mappingCandidates).map((match) => ({
+    cityName: match.cityName,
+    rigName: match.rigName,
+    rigPath: match.rigPath,
+  }));
+  const winner = matches[0];
+  if (!winner) {
+    return WorkspaceRigMappingSchema.parse({
+      state: "unmapped",
+      workspaceId: input.workspaceId,
+      workspacePath,
+      cityName: null,
+      rigName: null,
+      rigPath: null,
+      source: null,
+      candidates: [],
+      diagnostics: [],
+    });
+  }
+  const equallySpecific = matches.filter(
+    ({ canonicalRigPath }) => canonicalRigPath.length === winner.canonicalRigPath.length,
+  );
+  if (equallySpecific.length > 1) {
+    return WorkspaceRigMappingSchema.parse({
+      state: "ambiguous",
+      workspaceId: input.workspaceId,
+      workspacePath,
+      cityName: null,
+      rigName: null,
+      rigPath: null,
+      source: null,
+      candidates,
+      diagnostics: [
+        diagnostic(
+          "ambiguous-rig-mapping",
+          "Multiple equally specific Gas City rigs contain this workspace.",
+          false,
+        ),
+      ],
+    });
+  }
+  return WorkspaceRigMappingSchema.parse({
+    state: "mapped",
+    workspaceId: input.workspaceId,
+    workspacePath,
+    cityName: winner.cityName,
+    rigName: winner.rigName,
+    rigPath: winner.rigPath,
+    source: "longest-ancestor",
+    candidates,
+    diagnostics: [],
+  });
+}

package/shared/index.ts

@@ -0,0 +1,4 @@
+export { GAS_CITY_LIMITS } from "./limits";
+export * from "./rpc";
+export * from "./schemas";
+export * from "./settings";

package/shared/limits.ts

@@ -0,0 +1,28 @@
+export const GAS_CITY_LIMITS = {
+  endpointUrl: 2_048,
+  identifier: 256,
+  name: 256,
+  path: 4_096,
+  title: 4_096,
+  status: 128,
+  message: 16_384,
+  prompt: 131_072,
+  errorMessage: 2_048,
+  eventType: 256,
+  timestamp: 64,
+  cursor: 4_096,
+  metadataKey: 128,
+  metadataValue: 4_096,
+  metadataEntries: 64,
+  cities: 128,
+  rigs: 512,
+  sessions: 1_000,
+  convoys: 500,
+  workItems: 500,
+  events: 500,
+  attentionItems: 500,
+  diagnostics: 32,
+  mappingCandidates: 32,
+  providers: 128,
+  warnings: 32,
+} as const;

package/shared/rpc.ts

@@ -0,0 +1,99 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { GAS_CITY_LIMITS } from "./limits";
+import {
+  AttentionListSchema,
+  CityRigSnapshotSchema,
+  ConvoyListSchema,
+  DispatchRequestSchema,
+  DispatchResultSchema,
+  EventListSchema,
+  identifierSchema,
+  nameSchema,
+  SessionActionRequestSchema,
+  SessionActionResultSchema,
+  SessionListSchema,
+  SupervisorDiscoverySchema,
+  WorkListSchema,
+  WorkspaceRigMappingSchema,
+} from "./schemas";
+import { GasCityRpcSettingsSchema } from "./settings";
+
+const settingsInput = { settings: GasCityRpcSettingsSchema };
+const noInput = z.object(settingsInput).strict();
+const cityRigInput = z
+  .object({
+    ...settingsInput,
+    cityName: nameSchema,
+    rigName: nameSchema.nullable(),
+  })
+  .strict();
+
+export const discoverSupervisor = defineRpc({
+  name: "gas-city.discover-supervisor",
+  input: noInput,
+  output: SupervisorDiscoverySchema,
+});
+
+export const resolveWorkspaceRig = defineRpc({
+  name: "gas-city.resolve-workspace-rig",
+  input: z.object({ ...settingsInput, workspaceId: identifierSchema }).strict(),
+  output: WorkspaceRigMappingSchema,
+});
+
+export const getCityRigSnapshot = defineRpc({
+  name: "gas-city.get-city-rig-snapshot",
+  input: cityRigInput,
+  output: CityRigSnapshotSchema,
+});
+
+export const listSessions = defineRpc({
+  name: "gas-city.list-sessions",
+  input: cityRigInput,
+  output: SessionListSchema,
+});
+
+export const listConvoys = defineRpc({
+  name: "gas-city.list-convoys",
+  input: cityRigInput,
+  output: ConvoyListSchema,
+});
+export const listWork = defineRpc({
+  name: "gas-city.list-work",
+  input: cityRigInput,
+  output: WorkListSchema,
+});
+
+export const listEvents = defineRpc({
+  name: "gas-city.list-events",
+  input: z.discriminatedUnion("scope", [
+    z.object({ ...settingsInput, scope: z.literal("supervisor") }).strict(),
+    z
+      .object({
+        ...settingsInput,
+        scope: z.literal("city"),
+        cityName: nameSchema,
+        cursor: z.string().max(GAS_CITY_LIMITS.cursor).nullable(),
+      })
+      .strict(),
+  ]),
+  output: EventListSchema,
+});
+
+export const listAttention = defineRpc({
+  name: "gas-city.list-attention",
+  input: cityRigInput,
+  output: AttentionListSchema,
+});
+
+export const dispatchWork = defineRpc({
+  name: "gas-city.dispatch-work",
+  input: z.object({ ...settingsInput, request: DispatchRequestSchema }).strict(),
+  output: DispatchResultSchema,
+});
+
+export const performSessionAction = defineRpc({
+  name: "gas-city.perform-session-action",
+  input: z.object({ ...settingsInput, request: SessionActionRequestSchema }).strict(),
+  output: SessionActionResultSchema,
+});