larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/AGENTS.md

@@ -0,0 +1,9 @@
+<!-- BEGIN:nextjs-agent-rules -->
+
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` (resolved from this file's directory; in monorepos the `next` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by `next dev` — verify at `node_modules/next/dist/server/lib/generate-agent-files.js`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+<!-- END:nextjs-agent-rules -->

package/.next/standalone/apps/web/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/.next/standalone/apps/web/app/api/groups/route.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  createGroup: vi.fn(),
+  deleteGroup: vi.fn(),
+  listTabularDatasets: vi.fn(),
+  readDocuments: vi.fn(),
+  readGroups: vi.fn(),
+  readJobs: vi.fn(),
+  readMediaAssets: vi.fn(),
+  resolveTabularDatasetGroups: vi.fn(),
+  updateGroup: vi.fn(),
+}));
+
+vi.mock('@larkup/core/groups-store', () => ({
+  createGroup: mocks.createGroup,
+  deleteGroup: mocks.deleteGroup,
+  readGroups: mocks.readGroups,
+  updateGroup: mocks.updateGroup,
+}));
+vi.mock('@larkup/core/documents-store', () => ({ readDocuments: mocks.readDocuments }));
+vi.mock('@larkup/core/media-store', () => ({ readMediaAssets: mocks.readMediaAssets }));
+vi.mock('@larkup/core/jobs-store', () => ({ readJobs: mocks.readJobs }));
+vi.mock('@larkup/core/tabular-store', () => ({
+  listTabularDatasets: mocks.listTabularDatasets,
+  resolveTabularDatasetGroups: mocks.resolveTabularDatasetGroups,
+}));
+vi.mock('@larkup/core/project-store', () => ({
+  runWithProject: vi.fn((_projectId, operation) => operation()),
+}));
+
+import { DELETE, GET } from './route';
+
+const defaultGroup = {
+  id: 'default',
+  name: 'Default',
+  assistantEnabled: true,
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-01T00:00:00.000Z',
+};
+const researchGroup = { ...defaultGroup, id: 'research', name: 'Research' };
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.readGroups.mockResolvedValue([defaultGroup, researchGroup]);
+  mocks.readDocuments.mockResolvedValue([]);
+  mocks.readMediaAssets.mockResolvedValue([]);
+  mocks.listTabularDatasets.mockResolvedValue([]);
+  mocks.resolveTabularDatasetGroups.mockReturnValue([]);
+  mocks.readJobs.mockResolvedValue([]);
+});
+
+describe('groups API', () => {
+  it('counts each media asset once instead of counting its derived documents', async () => {
+    mocks.readDocuments.mockResolvedValue([
+      { id: 'text', source: 'text', groupId: 'research' },
+      { id: 'media-summary', source: 'media', groupId: 'research' },
+      {
+        id: 'media-segment',
+        source: 'media',
+        groupId: 'research',
+        parentSourceId: 'media-summary',
+      },
+    ]);
+    mocks.readMediaAssets.mockResolvedValue([{ id: 'video', groupId: 'research' }]);
+
+    const response = await GET(new Request('http://localhost/api/groups'));
+    const body = await response.json();
+
+    expect(body.groups).toContainEqual(expect.objectContaining({ id: 'research', sourceCount: 2 }));
+  });
+
+  it('refuses to delete a group while stored sources still reference it', async () => {
+    mocks.readDocuments.mockResolvedValue([{ id: 'text', source: 'text', groupId: 'research' }]);
+
+    const response = await DELETE(
+      new Request('http://localhost/api/groups?id=research', { method: 'DELETE' }),
+    );
+
+    expect(response.status).toBe(409);
+    await expect(response.json()).resolves.toEqual({
+      error: 'Move or delete this group’s sources before deleting the group.',
+    });
+    expect(mocks.deleteGroup).not.toHaveBeenCalled();
+  });
+});

package/.next/standalone/apps/web/app/api/index/route.test.ts

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  isRunning: vi.fn(),
+  readRun: vi.fn(),
+  readDocuments: vi.fn(),
+  corpusStats: vi.fn(),
+  createRun: vi.fn(),
+  runIndexer: vi.fn(),
+}));
+
+vi.mock('@larkup/core/config-store', () => ({ readConfig: vi.fn() }));
+vi.mock('@larkup/core/documents-store', () => ({
+  corpusStats: mocks.corpusStats,
+  readDocuments: mocks.readDocuments,
+}));
+vi.mock('@larkup/core/index-store', () => ({
+  isRunning: mocks.isRunning,
+  readRun: mocks.readRun,
+}));
+vi.mock('@larkup/core/indexing/indexer', () => ({
+  createRun: mocks.createRun,
+  runIndexer: mocks.runIndexer,
+}));
+vi.mock('@larkup/core/embeddings/registry', () => ({ getEmbeddingModel: vi.fn() }));
+vi.mock('@larkup/core/project-store', () => ({
+  runWithProject: vi.fn((_projectId, operation) => operation()),
+}));
+
+import { POST } from './route';
+
+describe('index queue API', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.readRun.mockResolvedValue({ id: 'active-run', status: 'embedding' });
+    mocks.readDocuments.mockResolvedValue([]);
+    mocks.corpusStats.mockResolvedValue({ docCount: 0, charCount: 0 });
+  });
+
+  it('queues another pass instead of rejecting files added during indexing', async () => {
+    mocks.isRunning.mockResolvedValueOnce(true).mockResolvedValue(false);
+
+    const response = await POST(
+      new Request('http://localhost/api/index', { method: 'POST', body: '{}' }),
+    );
+
+    expect(response.status).toBe(202);
+    await expect(response.json()).resolves.toMatchObject({
+      queued: true,
+      run: { id: 'active-run' },
+    });
+    await vi.waitFor(() => expect(mocks.readDocuments).toHaveBeenCalled());
+    expect(mocks.createRun).not.toHaveBeenCalled();
+  });
+});

package/.next/standalone/apps/web/app/api/marketplace/[toolId]/route.test.ts

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  getInstalledTool: vi.fn(),
+  getToolById: vi.fn(),
+  loadToolExtension: vi.fn(),
+  readConfig: vi.fn(),
+  unloadTool: vi.fn(),
+  uninstallTool: vi.fn(),
+  writeConfig: vi.fn(),
+}));
+
+vi.mock('@larkup/marketplace/registry', () => ({ getToolById: mocks.getToolById }));
+vi.mock('@larkup/marketplace/installer', () => ({
+  getInstalledTool: mocks.getInstalledTool,
+  installTool: vi.fn(),
+  isToolInstalled: vi.fn(),
+  uninstallTool: mocks.uninstallTool,
+}));
+vi.mock('@larkup/marketplace/loader', () => ({ unloadTool: mocks.unloadTool }));
+vi.mock('@larkup/marketplace/extension', () => ({ loadToolExtension: mocks.loadToolExtension }));
+vi.mock('@larkup/core/config-store', () => ({
+  readConfig: mocks.readConfig,
+  writeConfig: mocks.writeConfig,
+}));
+vi.mock('@larkup/core/project-store', () => ({
+  runWithProject: vi.fn((_projectId, operation) => operation()),
+}));
+
+import { DELETE } from './route';
+
+const context = { params: Promise.resolve({ toolId: 'video-intelligence' }) };
+const deviceConfig = {
+  enabledTools: ['video-intelligence', 'another-tool'],
+  toolConfigs: {
+    'video-intelligence': {
+      cloudInstallationId: 'af87929d-6b47-4fd5-9e09-a95d3b68d701',
+      cloudAccessKey: 'lvi_device_key',
+    },
+    'another-tool': { enabled: true },
+  },
+};
+
+beforeEach(() => {
+  for (const mock of Object.values(mocks)) mock.mockReset();
+  mocks.getInstalledTool.mockResolvedValue({ id: 'video-intelligence', config: {} });
+  mocks.loadToolExtension.mockResolvedValue({});
+  mocks.readConfig.mockResolvedValue(deviceConfig);
+  mocks.uninstallTool.mockResolvedValue(undefined);
+  mocks.writeConfig.mockResolvedValue(undefined);
+});
+
+describe('Video Intelligence uninstall', () => {
+  it('keeps the device-scoped cloud identity by default', async () => {
+    const response = await DELETE(
+      new Request('http://localhost/api/marketplace/video-intelligence', { method: 'DELETE' }),
+      context,
+    );
+
+    expect(await response.json()).toMatchObject({ status: 'uninstalled', configPurged: false });
+    expect(mocks.uninstallTool).toHaveBeenCalledWith('video-intelligence');
+    expect(mocks.writeConfig).toHaveBeenCalledWith({
+      ...deviceConfig,
+      enabledTools: ['another-tool'],
+    });
+  });
+
+  it('only removes the device identity when an explicit purge is requested', async () => {
+    const response = await DELETE(
+      new Request('http://localhost/api/marketplace/video-intelligence?purgeConfig=true', {
+        method: 'DELETE',
+      }),
+      context,
+    );
+
+    expect(await response.json()).toMatchObject({ status: 'uninstalled', configPurged: true });
+    expect(mocks.writeConfig).toHaveBeenCalledWith({
+      ...deviceConfig,
+      enabledTools: ['another-tool'],
+      toolConfigs: { 'another-tool': { enabled: true } },
+    });
+  });
+});

package/.next/standalone/apps/web/app/api/marketplace/route.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  compareToolVersions: vi.fn((available: string, installed: string) =>
+    available.localeCompare(installed, undefined, { numeric: true }),
+  ),
+  getAllTools: vi.fn(),
+  getDownloadCounts: vi.fn(),
+  getInstalledTools: vi.fn(),
+  getOngoingOperations: vi.fn(),
+  readFile: vi.fn(),
+  resolveWorkspaceToolPath: vi.fn(),
+}));
+
+vi.mock('node:fs', () => ({ promises: { readFile: mocks.readFile } }));
+vi.mock('@larkup/marketplace/registry', () => ({
+  compareToolVersions: mocks.compareToolVersions,
+  getAllTools: mocks.getAllTools,
+}));
+vi.mock('@larkup/marketplace/installer', () => ({
+  getDownloadCounts: mocks.getDownloadCounts,
+  getInstalledTools: mocks.getInstalledTools,
+  getOngoingOperations: mocks.getOngoingOperations,
+  resolveWorkspaceToolPath: mocks.resolveWorkspaceToolPath,
+}));
+
+import { GET } from './route';
+
+beforeEach(() => {
+  for (const mock of Object.values(mocks)) mock.mockReset();
+  mocks.compareToolVersions.mockImplementation((available: string, installed: string) =>
+    available.localeCompare(installed, undefined, { numeric: true }),
+  );
+  mocks.getAllTools.mockResolvedValue([
+    {
+      id: 'video-intelligence',
+      name: 'Video Intelligence',
+      version: '0.2.9',
+      downloads: 0,
+    },
+  ]);
+  mocks.getInstalledTools.mockResolvedValue([
+    {
+      id: 'video-intelligence',
+      version: '0.2.8',
+      source: 'registry',
+      packageName: '@larkup/tool-video-intelligence',
+      config: {},
+      installedAt: '2026-09-13T00:00:00.000Z',
+    },
+  ]);
+  mocks.getDownloadCounts.mockResolvedValue({});
+  mocks.getOngoingOperations.mockReturnValue({ installing: [], uninstalling: [] });
+  mocks.readFile.mockRejectedValue(new Error('not found'));
+});
+
+describe('marketplace catalog route', () => {
+  it('reports an installed tool separately from the newest catalog version', async () => {
+    const response = await GET();
+    const body = (await response.json()) as { tools: Array<Record<string, unknown>> };
+
+    expect(body.tools[0]).toMatchObject({
+      status: 'installed',
+      installedVersion: '0.2.8',
+      availableVersion: '0.2.9',
+      updateAvailable: true,
+    });
+  });
+
+  it('uses the installed package manifest when installed.json has a stale version', async () => {
+    mocks.getInstalledTools.mockResolvedValue([
+      {
+        id: 'video-intelligence',
+        version: '0.2.8',
+        source: 'registry',
+        packageName: '@larkup/tool-video-intelligence',
+        resolvedPath: '/tools/node_modules/@larkup/tool-video-intelligence',
+        config: {},
+        installedAt: '2026-09-13T00:00:00.000Z',
+      },
+    ]);
+    mocks.readFile.mockResolvedValue(JSON.stringify({ version: '0.2.9' }));
+
+    const response = await GET();
+    const body = (await response.json()) as { tools: Array<Record<string, unknown>> };
+
+    expect(body.tools[0]).toMatchObject({
+      installedVersion: '0.2.9',
+      availableVersion: '0.2.9',
+      updateAvailable: false,
+    });
+  });
+
+  it('does not offer an npm update for a workspace-linked tool', async () => {
+    mocks.getInstalledTools.mockResolvedValue([
+      {
+        id: 'video-intelligence',
+        version: '0.2.8',
+        source: 'local',
+        packageName: '@larkup/tool-video-intelligence',
+        resolvedPath: '/workspace/packages/marketplace-tools/video-intelligence',
+        config: {},
+        installedAt: '2026-09-13T00:00:00.000Z',
+      },
+    ]);
+    mocks.readFile.mockResolvedValue(JSON.stringify({ version: '0.2.8' }));
+
+    const response = await GET();
+    const body = (await response.json()) as { tools: Array<Record<string, unknown>> };
+
+    expect(body.tools[0]).toMatchObject({
+      installedVersion: '0.2.8',
+      availableVersion: '0.2.9',
+      updateAvailable: false,
+    });
+  });
+});

package/.next/standalone/apps/web/app/api/tools/[toolId]/verify/route.test.ts

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  getInstalledTool: vi.fn(),
+  loadToolExtension: vi.fn(),
+}));
+
+vi.mock('@larkup/core/config-store', () => ({ readConfig: vi.fn() }));
+vi.mock('@larkup/core/project-store', () => ({
+  runWithProject: vi.fn((_projectId, operation) => operation()),
+}));
+vi.mock('@larkup/marketplace/extension', () => ({
+  loadToolExtension: mocks.loadToolExtension,
+}));
+vi.mock('@larkup/marketplace/installer', () => ({
+  getInstalledTool: mocks.getInstalledTool,
+}));
+vi.mock('@/lib/marketplace/tool-runtime-config', () => ({
+  withGlobalVisionGatewayConfig: vi.fn((config) => config),
+}));
+
+import { POST } from './route';
+
+const context = { params: Promise.resolve({ toolId: 'video-intelligence' }) };
+
+beforeEach(() => {
+  mocks.getInstalledTool.mockReset();
+  mocks.loadToolExtension.mockReset();
+  mocks.getInstalledTool.mockResolvedValue({ id: 'video-intelligence', config: {} });
+});
+
+describe('tool verification route', () => {
+  it('reports a runtime loading failure separately from unsupported verification', async () => {
+    mocks.loadToolExtension.mockResolvedValue(null);
+
+    const response = await POST(
+      new Request('http://localhost/api/tools/video-intelligence/verify', {
+        method: 'POST',
+        body: '{}',
+      }),
+      context,
+    );
+
+    expect(response.status).toBe(503);
+    await expect(response.json()).resolves.toEqual({
+      error: 'Installed tool could not be loaded. Restart Larkup or reinstall the tool.',
+    });
+  });
+
+  it('reports unsupported verification only for a successfully loaded extension', async () => {
+    mocks.loadToolExtension.mockResolvedValue({ createClient: vi.fn() });
+
+    const response = await POST(
+      new Request('http://localhost/api/tools/video-intelligence/verify', {
+        method: 'POST',
+        body: '{}',
+      }),
+      context,
+    );
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toEqual({
+      error: 'This tool does not support verification.',
+    });
+  });
+});