remote-codex 0.11.41 → 0.11.42

package/apps/relay-server/dist/index.js

@@ -675,6 +675,20 @@ var RelayStore = class _RelayStore {
     ).get(deviceId, userId);
     return row ? { sandboxId: row.id, enabled: Boolean(row.workspace_isolation_enabled) } : null;
   }
+  hostedWorkspaceBootstrapContext(deviceId) {
+    const sandbox = this.hostedWorkspaceIsolation(deviceId);
+    if (!sandbox?.enabled) {
+      return null;
+    }
+    const users = this.sqlite.prepare(
+      `SELECT u.*
+           FROM relay_hosted_sandbox_members m
+           JOIN relay_users u ON u.id = m.user_id
+           WHERE m.sandbox_id = ? AND u.enabled = 1
+           ORDER BY m.position ASC, m.created_at ASC`
+    ).all(sandbox.sandboxId).map((row) => this.rowToUser(row)).filter((user) => Boolean(user)).map((user) => this.publicUser(user));
+    return { sandboxId: sandbox.sandboxId, users };
+  }
   hostedUserWorkspaceIds(sandboxId, userId) {
     return this.sqlite.prepare(
       `SELECT workspace_id FROM relay_hosted_user_workspaces
@@ -683,11 +697,24 @@ var RelayStore = class _RelayStore {
   }
   recordHostedUserWorkspace(sandboxId, userId, workspaceId, initial = false) {
     this.sqlite.prepare(
-      `INSERT OR IGNORE INTO relay_hosted_user_workspaces
+      `INSERT INTO relay_hosted_user_workspaces
           (sandbox_id, user_id, workspace_id, initial_workspace, created_at)
-         VALUES (?, ?, ?, ?, ?)`
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(sandbox_id, workspace_id) DO UPDATE SET
+           initial_workspace = MAX(
+             relay_hosted_user_workspaces.initial_workspace,
+             excluded.initial_workspace
+           )`
     ).run(sandboxId, userId, workspaceId, initial ? 1 : 0, (/* @__PURE__ */ new Date()).toISOString());
   }
+  hostedInitialWorkspaceId(sandboxId, userId) {
+    const row = this.sqlite.prepare(
+      `SELECT workspace_id FROM relay_hosted_user_workspaces
+         WHERE sandbox_id = ? AND user_id = ? AND initial_workspace = 1
+         ORDER BY created_at ASC LIMIT 1`
+    ).get(sandboxId, userId);
+    return row?.workspace_id ?? null;
+  }
   ownsHostedWorkspace(sandboxId, userId, workspaceId) {
     return Boolean(
       this.sqlite.prepare(
@@ -711,6 +738,15 @@ var RelayStore = class _RelayStore {
       ).get(sandboxId, userId, threadId)
     );
   }
+  hasHostedUserThreadInWorkspace(sandboxId, userId, workspaceId) {
+    return Boolean(
+      this.sqlite.prepare(
+        `SELECT 1 FROM relay_hosted_user_threads
+           WHERE sandbox_id = ? AND user_id = ? AND workspace_id = ?
+           LIMIT 1`
+      ).get(sandboxId, userId, workspaceId)
+    );
+  }
   listHostedProviderRecords() {
     return this.sqlite.prepare(
       "SELECT id, credential_ref FROM relay_hosted_sandboxes ORDER BY id"
@@ -3951,6 +3987,37 @@ function buildRelayServer(config2, options = {}) {
     hostedSandboxProvider,
     config2.hostedSandbox
   );
+  const scheduleHostedUserBootstraps = (deviceId) => {
+    const context = store.hostedWorkspaceBootstrapContext(deviceId);
+    const supervisor = state.supervisors.get(deviceId);
+    if (!context || !supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
+      return;
+    }
+    void Promise.allSettled(
+      context.users.map(
+        (bootstrapUser) => ensureHostedUserBootstrap({
+          store,
+          supervisor,
+          deviceId,
+          sandboxId: context.sandboxId,
+          user: bootstrapUser
+        })
+      )
+    ).then((results) => {
+      results.forEach((result, index) => {
+        if (result.status === "rejected") {
+          app2.log.warn(
+            {
+              err: result.reason,
+              deviceId,
+              userId: context.users[index]?.id
+            },
+            "Hosted VM user bootstrap failed."
+          );
+        }
+      });
+    });
+  };
   const allowedWebViewCorsOrigins = webViewCorsOrigins(
     options.env ?? process.env
   );
@@ -4303,10 +4370,12 @@ function buildRelayServer(config2, options = {}) {
       }
       const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
       const body = updateHostedSandboxMembersSchema.parse(request.body ?? {});
-      return hostedSandboxService.updateMembers(
+      const sandbox = hostedSandboxService.updateMembers(
         sandboxId,
         body.assignedUserIds
       );
+      scheduleHostedUserBootstraps(sandbox.deviceId);
+      return sandbox;
     }
   );
   app2.patch(
@@ -4316,10 +4385,14 @@ function buildRelayServer(config2, options = {}) {
       if (!user) return;
       const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
       const body = updateHostedSandboxSettingsSchema.parse(request.body ?? {});
-      return store.setHostedWorkspaceIsolation(
+      const sandbox = store.setHostedWorkspaceIsolation(
         sandboxId,
         body.workspaceIsolationEnabled
       );
+      if (sandbox.workspaceIsolationEnabled) {
+        scheduleHostedUserBootstraps(sandbox.deviceId);
+      }
+      return sandbox;
     }
   );
   app2.post(
@@ -4681,6 +4754,7 @@ function buildRelayServer(config2, options = {}) {
             clientConnection.socket.close();
           }
         });
+        scheduleHostedUserBootstraps(deviceId);
       }
     });
     realtimeApp.route({
@@ -5073,9 +5147,6 @@ async function forwardSharedThreadList(input) {
   );
 }
 async function ensureHostedUserBootstrap(input) {
-  if (input.store.hostedUserWorkspaceIds(input.sandboxId, input.user.id).length) {
-    return;
-  }
   const key = `${input.sandboxId}:${input.user.id}`;
   const existing = hostedBootstrapPromises.get(key);
   if (existing) return existing;
@@ -5084,55 +5155,69 @@ async function ensureHostedUserBootstrap(input) {
     const directory = `${slug}-${input.user.id.slice(0, 8)}`;
     const absoluteDirectory = `/home/remote-codex/workspaces/${directory}`;
     const label = `${input.user.username}'s workspace`;
-    const current = await forwardSupervisorCommandJson(
-      input.supervisor,
-      input.deviceId,
-      "GET",
-      "/api/workspaces"
-    );
-    const currentWorkspaces = Array.isArray(current) ? current : [];
-    let workspace = currentWorkspaces.find(
-      (candidate) => isObject(candidate) && typeof candidate.absPath === "string" && candidate.absPath === absoluteDirectory
+    let workspaceId = input.store.hostedInitialWorkspaceId(
+      input.sandboxId,
+      input.user.id
     );
-    if (!workspace) {
-      workspace = await forwardSupervisorCommandJson(
+    if (!workspaceId) {
+      const current = await forwardSupervisorCommandJson(
         input.supervisor,
         input.deviceId,
-        "POST",
-        "/api/workspaces",
-        { absPath: absoluteDirectory, label }
+        "GET",
+        "/api/workspaces"
       );
-    }
-    const workspaceId = stringField(workspace, "id");
-    if (!workspaceId) throw new Error("Initial workspace creation returned no id.");
-    const thread = await forwardSupervisorCommandJson(
-      input.supervisor,
-      input.deviceId,
-      "POST",
-      "/api/threads/start",
-      {
-        workspaceId,
-        title: "Getting started",
-        provider: "codex",
-        model: "gpt-5.6-sol",
-        reasoningEffort: "low",
-        approvalMode: "yolo"
+      const currentWorkspaces = Array.isArray(current) ? current : [];
+      let workspace = currentWorkspaces.find(
+        (candidate) => isObject(candidate) && typeof candidate.absPath === "string" && candidate.absPath === absoluteDirectory
+      );
+      if (!workspace) {
+        workspace = await forwardSupervisorCommandJson(
+          input.supervisor,
+          input.deviceId,
+          "POST",
+          "/api/workspaces",
+          { absPath: absoluteDirectory, label }
+        );
       }
-    );
-    const threadId = stringField(thread, "id");
-    if (!threadId) throw new Error("Initial thread creation returned no id.");
-    input.store.recordHostedUserWorkspace(
-      input.sandboxId,
-      input.user.id,
-      workspaceId,
-      true
-    );
-    input.store.recordHostedUserThread(
+      workspaceId = stringField(workspace, "id");
+      if (!workspaceId) {
+        throw new Error("Initial workspace creation returned no id.");
+      }
+      input.store.recordHostedUserWorkspace(
+        input.sandboxId,
+        input.user.id,
+        workspaceId,
+        true
+      );
+    }
+    if (!input.store.hasHostedUserThreadInWorkspace(
       input.sandboxId,
       input.user.id,
-      threadId,
       workspaceId
-    );
+    )) {
+      const thread = await forwardSupervisorCommandJson(
+        input.supervisor,
+        input.deviceId,
+        "POST",
+        "/api/threads/start",
+        {
+          workspaceId,
+          title: "Getting started",
+          provider: "codex",
+          model: "gpt-5.6-sol",
+          reasoningEffort: "low",
+          approvalMode: "yolo"
+        }
+      );
+      const threadId = stringField(thread, "id");
+      if (!threadId) throw new Error("Initial thread creation returned no id.");
+      input.store.recordHostedUserThread(
+        input.sandboxId,
+        input.user.id,
+        threadId,
+        workspaceId
+      );
+    }
   })().finally(() => hostedBootstrapPromises.delete(key));
   hostedBootstrapPromises.set(key, pending);
   return pending;
@@ -5763,7 +5848,9 @@ function isAllowedSharedRuntimeMetadataRequest(method, pathname) {
 function threadIdFromPath(pathValue) {
   const pathname = new URL(pathValue, "http://relay.local").pathname;
   const match = /^\/api\/threads\/([^/?#]+)/.exec(pathname);
-  return match ? decodeURIComponent(match[1]) : null;
+  if (!match) return null;
+  const threadId = decodeURIComponent(match[1]);
+  return threadId === "start" || threadId === "import" ? null : threadId;
 }
 function workspaceIdFromPath(pathValue) {
   const pathname = new URL(pathValue, "http://relay.local").pathname;

package/apps/supervisor-api/dist/index.js

@@ -16459,7 +16459,7 @@ var ThreadAuxiliaryStateStore = class {
       );
       return {
         id: record.id,
-        kind: "fastMode",
+        kind: record.kind === "goal" ? "goal" : "fastMode",
         text: record.text,
         createdAt: record.createdAt,
         anchorTurnId: record.anchorTurnId ?? fallbackAnchor?.id ?? null
@@ -16673,13 +16673,10 @@ var ThreadGoalCoordinator = class {
     }
     try {
       await this.ensureGoalsFeatureEnabled(record.provider);
-      const activeGoal = this.listThreadGoalHistory(record.id).find(
+      const goalHistoryBeforeUpdate = this.listThreadGoalHistory(record.id);
+      const activeGoal = goalHistoryBeforeUpdate.find(
         (goal2) => ["active", "paused", "budgetLimited"].includes(goal2.status)
       ) ?? null;
-      const creatingNewGoal = goalObjectiveChanged(activeGoal, input.objective);
-      if (creatingNewGoal) {
-        markActiveThreadGoalRecordTerminated(this.db, record.id);
-      }
       if (input.status === "terminated") {
         const terminatedGoal = markActiveThreadGoalRecordTerminated(this.db, record.id);
         const goalHistory = this.listThreadGoalHistory(record.id);
@@ -16690,6 +16687,23 @@ var ThreadGoalCoordinator = class {
         });
         return goal2;
       }
+      const startingNewGoal = shouldStartNewGoal(activeGoal, input.objective);
+      if (startingNewGoal && (record.providerTurnId || record.status === "running")) {
+        throw new HttpError(409, {
+          code: "conflict",
+          message: "Interrupt the running turn before replacing this goal."
+        });
+      }
+      if (startingNewGoal && goalHistoryBeforeUpdate.length > 0) {
+        if (!runtime.clearGoal) {
+          throw new HttpError(409, {
+            code: "conflict",
+            message: "This backend cannot safely replace an existing goal."
+          });
+        }
+        await runtime.clearGoal(providerSessionId);
+        markActiveThreadGoalRecordTerminated(this.db, record.id);
+      }
       const upstreamStatus = input.status;
       const goal = await runtime.setGoal({
         providerSessionId,
@@ -16701,10 +16715,15 @@ var ThreadGoalCoordinator = class {
         toThreadGoalDtoFromAgentGoal(goal),
         record
       );
-      const dto = creatingNewGoal ? resetGoalProgress(upstreamDto) : upstreamDto;
+      const dto = startingNewGoal ? startFreshGoalLifecycle(upstreamDto) : upstreamDto;
       const persistedGoal = toThreadGoalDtoFromRecord(
-        this.persistThreadGoalSnapshot(record.id, dto)
+        this.persistThreadGoalSnapshot(record.id, dto, {
+          createNew: startingNewGoal
+        })
       );
+      if (startingNewGoal) {
+        this.callbacks.appendGoalActivityNote(record.id, persistedGoal.objective);
+      }
       this.callbacks.emitThreadEvent("thread.goal.updated", record.id, {
         goal: persistedGoal,
         goalHistory: this.listThreadGoalHistory(record.id)
@@ -16772,12 +16791,13 @@ var ThreadGoalCoordinator = class {
       throw error;
     }
   }
-  persistThreadGoalSnapshot(localThreadId, goal) {
+  persistThreadGoalSnapshot(localThreadId, goal, options = {}) {
     const dto = "createdAt" in goal && typeof goal.createdAt === "string" ? goal : toThreadGoalDto(goal);
     return upsertThreadGoalRecord(this.db, {
       threadId: localThreadId,
       providerSessionId: dto.threadId,
       localGoalId: dto.localGoalId ?? null,
+      createNew: options.createNew ?? false,
       objective: dto.objective,
       status: dto.status,
       tokenBudget: dto.tokenBudget,
@@ -16900,15 +16920,19 @@ function mergeGoalHistoryEntry(existing, incoming) {
 function goalHistoryStatusRank(status) {
   return ["active", "paused", "budgetLimited"].includes(status) ? 0 : 1;
 }
-function resetGoalProgress(goal) {
+function startFreshGoalLifecycle(goal) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     ...goal,
     tokensUsed: 0,
-    timeUsedSeconds: 0
+    timeUsedSeconds: 0,
+    createdAt: now,
+    updatedAt: now,
+    completedAt: null
   };
 }
-function goalObjectiveChanged(existing, nextObjective) {
-  return existing !== null && typeof nextObjective === "string" && nextObjective.trim().length > 0 && nextObjective !== existing.objective;
+function shouldStartNewGoal(existing, nextObjective) {
+  return typeof nextObjective === "string" && nextObjective.trim().length > 0 && (existing === null || nextObjective !== existing.objective);
 }
 function isLocalGoalStatus(status) {
   return ["active", "paused", "budgetLimited"].includes(status);
@@ -18109,6 +18133,14 @@ var ThreadRuntimeEventProjector = class {
         if (!record) {
           return;
         }
+        const currentGoal = await callbacks.getThreadGoalAfterRuntimeClear(record);
+        if (currentGoal) {
+          callbacks.emitThreadEvent("thread.goal.updated", record.id, {
+            goal: currentGoal,
+            goalHistory: callbacks.listThreadGoalHistory(record.id)
+          });
+          return;
+        }
         markActiveThreadGoalRecordTerminated(db, record.id);
         callbacks.emitThreadEvent("thread.goal.cleared", record.id, {
           goalHistory: callbacks.listThreadGoalHistory(record.id)
@@ -22423,7 +22455,11 @@ var ThreadService = class {
     this.goalCoordinator = new ThreadGoalCoordinator(db, providerFeatures, {
       emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
       requireProviderSessionId: (record) => this.requireProviderSessionId(record),
-      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2)
+      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2),
+      appendGoalActivityNote: (threadId, objective) => this.auxiliaryState.appendActivityNote(threadId, {
+        kind: "goal",
+        text: objective
+      })
     });
     this.auxiliaryState = new ThreadAuxiliaryStateStore(db, {
       cachedTurns: (localThreadId) => this.detailAssembler.cachedTurns(localThreadId),
@@ -22521,6 +22557,7 @@ var ThreadService = class {
         resetThreadContextUsage: (localThreadId, emitEvent) => this.resetThreadContextUsage(localThreadId, emitEvent),
         setThreadContextUsage: (localThreadId, usage, emitEvent) => this.setThreadContextUsage(localThreadId, usage, emitEvent),
         getThreadContextUsage: (localThreadId) => this.getThreadContextUsage(localThreadId),
+        getThreadGoalAfterRuntimeClear: (record) => this.goalCoordinator.getThreadGoalForRecord(record),
         toThreadGoalDtoFromAgentGoal: (goal) => this.goalCoordinator.toThreadGoalDtoFromAgentGoal(goal),
         toThreadGoalDtoFromRecord: (record) => this.goalCoordinator.toThreadGoalDtoFromRecord(record)
       }