@axiom-lattice/gateway 2.1.92 → 2.1.94

package/src/controllers/assistant.ts

@@ -31,6 +31,12 @@ function getTenantId(request: FastifyRequest): string {
   return (request.headers["x-tenant-id"] as string) || "default";
 }
 
+function getUserId(request: FastifyRequest): string | undefined {
+  const userId = (request as any).user?.id;
+  if (userId) return userId;
+  return (request.headers["x-user-id"] as string) || undefined;
+}
+
 /**
  * Convert AgentConfig to Assistant format
  */
@@ -112,12 +118,19 @@ export async function getAssistantList(
 
   const allAssistants = Array.from(assistantMap.values());
 
+  // Filter: exclude personal assistants owned by other users
+  const userId = getUserId(request);
+  const filtered = allAssistants.filter((a) => {
+    if (!a.ownerUserId) return true;
+    return a.ownerUserId === userId;
+  });
+
   return {
     success: true,
     message: "Successfully retrieved assistant list",
     data: {
-      records: allAssistants,
-      total: allAssistants.length,
+      records: filtered,
+      total: filtered.length,
     },
   };
 }

package/src/controllers/auth.ts

@@ -251,6 +251,10 @@ export class AuthController {
 
       const token = await this.generateToken(userId, tenantId);
 
+      // Check for personal assistant in this tenant
+      const link = await this.userTenantLinkStore.getLink(userId, tenantId);
+      const linkMeta = (link?.metadata || {}) as Record<string, unknown>;
+
       return {
         success: true,
         data: {
@@ -260,6 +264,11 @@ export class AuthController {
             status: tenant.status,
           },
           token,
+          personalAssistant: linkMeta.personalAssistantId ? {
+            assistantId: linkMeta.personalAssistantId as string,
+            projectId: linkMeta.personalProjectId as string || "default",
+            workspaceId: linkMeta.personalWorkspaceId as string || "default",
+          } : null,
         },
       };
     } catch (error) {

package/src/controllers/menu-items.ts

@@ -0,0 +1,114 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import type { CreateMenuItemInput } from "@axiom-lattice/protocols";
+import { getMenuRegistry } from "@axiom-lattice/core";
+
+function getTenantId(request: FastifyRequest): string {
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : "Unexpected error";
+}
+
+export async function getMenuItemList(
+  request: FastifyRequest<{
+    Querystring: { menuTarget?: string };
+  }>,
+  _reply: FastifyReply,
+) {
+  const tenantId = getTenantId(request);
+  try {
+    const registry = getMenuRegistry();
+    const items = await registry.list({ tenantId, menuTarget: request.query.menuTarget as "sidebar" | "workspace" | undefined });
+    return { success: true, message: "Menu items retrieved", data: { records: items, total: items.length } };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to get menu items:", msg);
+    return { success: false, message: msg, data: { records: [], total: 0 } };
+  }
+}
+
+export async function getMenuItem(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const tenantId = getTenantId(request);
+  try {
+    const registry = getMenuRegistry();
+    const item = await registry.getById(request.params.id);
+    if (!item || item.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    return { success: true, message: "Menu item retrieved", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to get menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+
+export async function createMenuItem(
+  request: FastifyRequest<{ Body: CreateMenuItemInput }>,
+  reply: FastifyReply,
+) {
+  const tenantId = getTenantId(request);
+  try {
+    const registry = getMenuRegistry();
+    const item = await registry.create({ ...request.body, tenantId });
+    reply.status(201);
+    return { success: true, message: "Menu item created", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to create menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+
+export async function updateMenuItem(
+  request: FastifyRequest<{ Params: { id: string }; Body: Partial<CreateMenuItemInput & { enabled: boolean }> }>,
+  reply: FastifyReply,
+) {
+  try {
+    const tenantId = getTenantId(request);
+    const registry = getMenuRegistry();
+    const existing = await registry.getById(request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    const item = await registry.update(request.params.id, request.body);
+    return { success: true, message: "Menu item updated", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to update menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+
+export async function deleteMenuItem(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  try {
+    const tenantId = getTenantId(request);
+    const registry = getMenuRegistry();
+    const existing = await registry.getById(request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    await registry.delete(request.params.id);
+    return { success: true, message: "Menu item deleted" };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to delete menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}

package/src/controllers/personal-assistant.ts

@@ -0,0 +1,191 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice, PersonalAssistantConfig } from "@axiom-lattice/core";
+import type { Assistant, CreateAssistantRequest } from "@axiom-lattice/protocols";
+import { randomUUID } from "crypto";
+function getWorkspaceId(request: FastifyRequest): string {
+  return (request.headers["x-workspace-id"] as string) || "default";
+}
+
+function getTenantId(request: FastifyRequest): string {
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+function getUserId(request: FastifyRequest): string {
+  const userId = (request as any).user?.id
+    || (request.headers["x-user-id"] as string);
+  if (!userId) throw new Error("User ID is required");
+  return userId;
+}
+
+interface CreatePersonalAssistantBody {
+  name: string;
+  personality: string;
+}
+
+interface PersonalAssistantStatus {
+  id: string;
+  name: string;
+  projectId: string;
+  workspaceId?: string;
+  createdAt: Date;
+}
+
+interface PersonalAssistantResponse {
+  success: boolean;
+  message: string;
+  data?: PersonalAssistantStatus;
+}
+
+function getLinkStore() {
+  return getStoreLattice("default", "userTenantLink").store;
+}
+
+function getAssistantStore() {
+  return getStoreLattice("default", "assistant").store;
+}
+
+function getProjectStore() {
+  return getStoreLattice("default", "project").store;
+}
+
+async function getLinkMeta(userId: string, tenantId: string) {
+  const link = await getLinkStore().getLink(userId, tenantId);
+  return (link?.metadata || {}) as Record<string, unknown>;
+}
+
+async function updateLinkMeta(userId: string, tenantId: string, meta: Record<string, unknown>) {
+  await getLinkStore().updateLink(userId, tenantId, { metadata: meta } as any);
+}
+
+/**
+ * Create a personal assistant for the authenticated user.
+ * Random IDs for both assistant and project, stored in UserTenantLink.metadata.
+ */
+export async function createPersonalAssistant(
+  request: FastifyRequest<{ Body: CreatePersonalAssistantBody }>,
+  reply: FastifyReply
+): Promise<PersonalAssistantResponse> {
+  const tenantId = getTenantId(request);
+  const userId = getUserId(request);
+  const { name, personality } = request.body;
+
+  if (!name || !personality) {
+    return reply.status(400).send({ success: false, message: "name and personality are required" });
+  }
+
+  const store = getAssistantStore();
+
+  const existing = await store.getByOwner(tenantId, userId);
+  if (existing) {
+    return reply.status(409).send({ success: false, message: "You already have a personal assistant" });
+  }
+
+  const assistantId = randomUUID();
+
+  // Create a personal project under the current workspace
+  const projectStore = getProjectStore();
+  const projectId = randomUUID();
+  const wsId = getWorkspaceId(request);
+  await projectStore.createProject(tenantId, wsId, projectId, {
+    name: `${name}'s Space`,
+    description: "Personal workspace for your assistant",
+  });
+
+  const config = PersonalAssistantConfig.get();
+  config.key = assistantId;
+  PersonalAssistantConfig.render(config, name, personality);
+
+  const data: CreateAssistantRequest = { name, graphDefinition: config, ownerUserId: userId };
+  const assistant = await store.createAssistant(tenantId, assistantId, data);
+
+  // Store in UserTenantLink.metadata
+  const meta = await getLinkMeta(userId, tenantId);
+  meta.personalAssistantId = assistantId;
+  meta.personalProjectId = projectId;
+  meta.personalWorkspaceId = wsId;
+  await updateLinkMeta(userId, tenantId, meta);
+
+  return reply.status(201).send({
+    success: true,
+    message: "Personal assistant created",
+    data: { id: assistant.id, name: assistant.name, projectId, workspaceId: wsId, createdAt: assistant.createdAt },
+  });
+}
+
+/**
+ * Get the authenticated user's personal assistant.
+ */
+export async function getPersonalAssistant(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<PersonalAssistantResponse> {
+  const tenantId = getTenantId(request);
+  const userId = getUserId(request);
+
+  const store = getAssistantStore();
+  const assistant = await store.getByOwner(tenantId, userId);
+
+  if (!assistant) {
+    return reply.status(404).send({ success: false, message: "No personal assistant found" });
+  }
+
+  const meta = await getLinkMeta(userId, tenantId);
+  const projectId = (meta.personalProjectId as string) || "default";
+  const workspaceId = (meta.personalWorkspaceId as string) || "default";
+
+  return {
+    success: true,
+    message: "Personal assistant found",
+    data: { id: assistant.id, name: assistant.name, projectId, workspaceId, createdAt: assistant.createdAt },
+  };
+}
+
+/**
+ * Delete the authenticated user's personal assistant.
+ */
+export async function deletePersonalAssistant(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<{ success: boolean; message: string }> {
+  const tenantId = getTenantId(request);
+  const userId = getUserId(request);
+
+  const store = getAssistantStore();
+  const assistant = await store.getByOwner(tenantId, userId);
+
+  if (!assistant) {
+    return reply.status(404).send({ success: false, message: "No personal assistant found" });
+  }
+
+  const deleted = await store.deleteAssistant(tenantId, assistant.id);
+  if (!deleted) {
+    return reply.status(500).send({ success: false, message: "Failed to delete personal assistant" });
+  }
+
+  // Delete all threads
+  const threadStore = getStoreLattice("default", "thread").store;
+  try {
+    const threads = await threadStore.getThreadsByAssistantId(tenantId, assistant.id);
+    for (const t of threads) {
+      await threadStore.deleteThread(tenantId, t.id);
+    }
+  } catch { /* best effort */ }
+
+  // Clean up the project
+  const meta = await getLinkMeta(userId, tenantId);
+  const projectId = meta.personalProjectId as string;
+  const wsId = meta.personalWorkspaceId as string;
+  if (projectId && wsId) {
+    try { await getProjectStore().deleteProject(tenantId, projectId); } catch { /* best effort */ }
+  }
+
+  // Clean up UserTenantLink.metadata
+  delete meta.personalAssistantId;
+  delete meta.personalProjectId;
+  delete meta.personalWorkspaceId;
+  await updateLinkMeta(userId, tenantId, meta);
+
+  return { success: true, message: "Personal assistant deleted" };
+}

package/src/controllers/run.ts

@@ -262,3 +262,50 @@ export const abortRun = async (
     });
   }
 };
+
+/**
+ * Recover agent execution after a crash or manual abort.
+ *
+ * Resumes the LangGraph from its last checkpoint if the graph was
+ * mid-execution (BUSY).  Otherwise cleans up stuck queue messages
+ * and restarts the queue processor.
+ *
+ * Pairs with {@link abortRun} — use abort to stop, recover to continue.
+ */
+export const recoverRun = async (
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<void> => {
+  try {
+    const { assistantId, threadId } = request.params as {
+      assistantId: string;
+      threadId: string;
+    };
+    const tenant_id = request.headers["x-tenant-id"] as string;
+    const workspace_id = (request.headers["x-workspace-id"] as string) || "default";
+    const project_id = (request.headers["x-project-id"] as string) || "default";
+
+    const agent = agentInstanceManager.getAgent({
+      assistant_id: assistantId,
+      thread_id: threadId,
+      tenant_id,
+      workspace_id,
+      project_id,
+    });
+
+    await agent.resumeTask();
+
+    const status = await agent.getRunStatus();
+
+    reply.status(200).send({
+      success: true,
+      threadId,
+      status,
+    });
+  } catch (error: any) {
+    reply.status(500).send({
+      success: false,
+      error: `Recover failed: ${error.message}`,
+    });
+  }
+};

package/src/controllers/tasks.ts

@@ -0,0 +1,187 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice } from "@axiom-lattice/core";
+import type { TaskStore, TaskItem, CreateTaskRequest, UpdateTaskRequest } from "@axiom-lattice/protocols";
+
+function getTenantId(request: FastifyRequest): string {
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+function getUserId(request: FastifyRequest): string {
+  const userId = (request as any).user?.id
+    || (request.headers["x-user-id"] as string);
+  if (!userId) throw new Error("User ID is required");
+  return userId;
+}
+
+function getStore(): TaskStore {
+  return getStoreLattice("default", "task").store as TaskStore;
+}
+
+export async function listTasks(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<{ success: boolean; data?: TaskItem[]; count?: number; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const query = request.query as Record<string, string>;
+
+    const store = getStore();
+    const tasks = await store.list({
+      tenantId,
+      ownerId: query.ownerId || userId,
+      status: query.status,
+      priority: query.priority,
+      ownerType: query.ownerType as 'user' | 'agent' | undefined,
+      metadata: query.metadata ? JSON.parse(query.metadata) : undefined,
+      limit: query.limit ? parseInt(query.limit) : undefined,
+      offset: query.offset ? parseInt(query.offset) : undefined,
+    });
+
+    return { success: true, data: tasks, count: tasks.length };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function getTask(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const { id } = request.params;
+
+    const store = getStore();
+    const task = await store.getById(tenantId, id);
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+
+    if (task.ownerType === 'user' && task.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+
+    return { success: true, data: task };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function createTask(
+  request: FastifyRequest<{ Body: CreateTaskRequest }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const body = request.body;
+
+    if (!body.title) {
+      return reply.status(400).send({ success: false, error: "title is required" });
+    }
+
+    const store = getStore();
+    const task = await store.create({
+      ...body,
+      tenantId,
+      ownerType: (body.ownerType || "user") as 'user' | 'agent',
+      ownerId: body.ownerId || userId,
+    });
+
+    return reply.status(201).send({ success: true, data: task });
+  } catch (error: any) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+
+export async function updateTask(
+  request: FastifyRequest<{ Params: { id: string }; Body: UpdateTaskRequest }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const { id } = request.params;
+
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+
+    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+
+    const task = await store.update(tenantId, id, request.body);
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    return { success: true, data: task };
+  } catch (error: any) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+
+export async function deleteTask(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; message?: string; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const { id } = request.params;
+
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+
+    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+
+    const deleted = await store.delete(tenantId, id);
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+
+    return { success: true, message: "Task deleted" };
+  } catch (error: any) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+
+export async function completeTask(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<{ success: boolean; data?: TaskItem; error?: string }> {
+  try {
+    const tenantId = getTenantId(request);
+    const userId = getUserId(request);
+    const { id } = request.params;
+
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+
+    if (existing.ownerType === 'user' && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+
+    const task = await store.update(tenantId, id, { status: "completed" });
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    return { success: true, data: task };
+  } catch (error: any) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}

package/src/controllers/workspace.ts

@@ -262,6 +262,8 @@ export class WorkspaceController {
       throw new Error("Workspace not found");
     }
 
+    console.log(`[getBackend] storageType=${workspace.storageType} filePath=${filePath}`);
+
     if (workspace.storageType === "sandbox") {
       const sandboxManager = getSandBoxManager();
 
@@ -273,18 +275,23 @@ export class WorkspaceController {
         projectId,
       };
 
+      console.log(`[getBackend] trying volume backend for path=${filePath} assistant_id=${assistantId}`);
       const volumeBackend = await sandboxManager.getVolumeBackendForPath(volumeConfig, filePath || "/project");
       if (volumeBackend) {
+        console.log(`[getBackend] using VolumeFilesystem`);
         return { backend: volumeBackend, workspace };
       }
 
+      console.log(`[getBackend] volume not found, falling back to SandboxFilesystem`);
       const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
+      console.log(`[getBackend] sandbox acquired, name=${(sandbox as any).name || "unknown"}`);
       return {
         backend: new SandboxFilesystem({
           sandboxInstance: sandbox,
         }), workspace
       };
     } else {
+      console.log(`[getBackend] using FilesystemBackend rootDir=/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`);
       return {
         backend: new FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
@@ -549,8 +556,13 @@ export class WorkspaceController {
     const path = (request.query.path as string) || "/";
     const assistantId = request.query.assistantId;
 
+    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path} assistantId=${assistantId}`);
+
     const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path);
+    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path})`);
+
     const files = await backend.lsInfo(path);
+    console.log(`[listPath] result count=${files.length}`);
 
     return { success: true, data: files };
   }