larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/store/deploy-store.ts

@@ -0,0 +1,90 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+// Persisted deployment credentials.
+
+interface PersistedCredentials {
+  vercelToken: string;
+  vercelProject: string;
+  // SSH credentials keyed by provider.
+  sshCredentials: Record<
+    string,
+    { host: string; username: string; authType: 'key' | 'password'; credential: string }
+  >;
+  deployStorage: {
+    storeId?: string;
+    storeConfig?: Record<string, string>;
+    embeddingModelId?: string;
+  };
+}
+
+interface PersistedActions {
+  setVercelToken: (token: string) => void;
+  setVercelProject: (project: string) => void;
+  setSshCredential: (
+    provider: string,
+    cred: { host: string; username: string; authType: 'key' | 'password'; credential: string },
+  ) => void;
+  setDeployStorage: (storage: Partial<PersistedCredentials['deployStorage']>) => void;
+}
+
+export const useDeployCredentialsStore = create<PersistedCredentials & PersistedActions>()(
+  persist(
+    (set) => ({
+      vercelToken: '',
+      vercelProject: '',
+      sshCredentials: {},
+      deployStorage: {},
+
+      setVercelToken: (token) => set({ vercelToken: token }),
+      setVercelProject: (project) => set({ vercelProject: project }),
+      setSshCredential: (provider, cred) =>
+        set((prev) => ({
+          sshCredentials: { ...prev.sshCredentials, [provider]: cred },
+        })),
+      setDeployStorage: (storage) =>
+        set((prev) => ({
+          deployStorage: { ...prev.deployStorage, ...storage },
+        })),
+    }),
+    {
+      name: 'larkup-deploy-credentials',
+    },
+  ),
+);
+
+// Ephemeral VPS terminal state; intentionally not persisted.
+
+export type VpsTerminalState = 'deploying' | 'password_required' | 'success' | 'error';
+
+interface VpsTerminalStore {
+  open: boolean;
+  logs: string[];
+  state: VpsTerminalState;
+  url?: string;
+  error?: string;
+
+  openTerminal: () => void;
+  closeTerminal: () => void;
+  reset: () => void;
+  appendLog: (line: string) => void;
+  setState: (state: VpsTerminalState) => void;
+  setUrl: (url: string) => void;
+  setError: (error: string) => void;
+}
+
+export const useVpsTerminalStore = create<VpsTerminalStore>()((set) => ({
+  open: false,
+  logs: [],
+  state: 'deploying',
+  url: undefined,
+  error: undefined,
+
+  openTerminal: () => set({ open: true }),
+  closeTerminal: () => set({ open: false }),
+  reset: () => set({ logs: [], state: 'deploying', url: undefined, error: undefined }),
+  appendLog: (line) => set((prev) => ({ logs: [...prev.logs, line] })),
+  setState: (state) => set({ state }),
+  setUrl: (url) => set({ url }),
+  setError: (error) => set({ error }),
+}));

package/.next/standalone/apps/web/store/scrape-store.ts

@@ -0,0 +1,76 @@
+import { create } from 'zustand';
+import type { CrawlScope, SearchResultItem } from '@larkup/core/types';
+
+export interface SearchState {
+  results: SearchResultItem[];
+  totalResults: number;
+  totalResultsIsEstimate: boolean;
+  currentPage: number;
+  totalPages: number;
+  hasMore: boolean;
+  query: string;
+  searchProvider: 'firecrawl' | 'serper' | 'google' | 'brave' | 'bing' | 'tavily';
+}
+
+type StateUpdate<T> = T | ((previous: T) => T);
+
+interface ScrapeStore {
+  query: string;
+  searchState: SearchState | null;
+  selected: Record<string, boolean>;
+  scope: CrawlScope;
+  pageLimit: number;
+  searchLimit: number;
+  showAdvanced: boolean;
+  serperTotalForQuery: { query: string; total: number; totalPages: number } | null;
+
+  setQuery: (query: string) => void;
+  setSearchState: (state: StateUpdate<SearchState | null>) => void;
+  setSelected: (selected: StateUpdate<Record<string, boolean>>) => void;
+  setScope: (scope: CrawlScope) => void;
+  setPageLimit: (limit: number) => void;
+  setSearchLimit: (limit: number) => void;
+  setShowAdvanced: (show: boolean) => void;
+  setSerperTotalForQuery: (
+    value: StateUpdate<{ query: string; total: number; totalPages: number } | null>,
+  ) => void;
+
+  flush: () => void;
+}
+
+export const useScrapeStore = create<ScrapeStore>()((set) => ({
+  query: '',
+  searchState: null,
+  selected: {},
+  scope: 'domain',
+  pageLimit: 25,
+  searchLimit: 15,
+  showAdvanced: false,
+  serperTotalForQuery: null,
+
+  setQuery: (query) => set({ query }),
+  setSearchState: (state) =>
+    set((prev) => ({
+      searchState: typeof state === 'function' ? state(prev.searchState) : state,
+    })),
+  setSelected: (selected) =>
+    set((prev) => ({
+      selected: typeof selected === 'function' ? selected(prev.selected) : selected,
+    })),
+  setScope: (scope) => set({ scope }),
+  setPageLimit: (limit) => set({ pageLimit: limit }),
+  setSearchLimit: (limit) => set({ searchLimit: limit }),
+  setShowAdvanced: (show) => set({ showAdvanced: show }),
+  setSerperTotalForQuery: (value) =>
+    set((prev) => ({
+      serperTotalForQuery: typeof value === 'function' ? value(prev.serperTotalForQuery) : value,
+    })),
+
+  flush: () =>
+    set({
+      query: '',
+      searchState: null,
+      selected: {},
+      serperTotalForQuery: null,
+    }),
+}));

package/.next/standalone/apps/web/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "target": "ES6",
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "../../archive/assistant-capabilities-section.tsx",
+    "../../archive/project-deploy-sheet.tsx",
+    "../../archive/theme-switcher.tsx",
+    "../../archive/page-header.tsx",
+    "../../archive/simple-setup.tsx",
+    "../../archive/tech-setup.tsx",
+    "../../archive/firecrawl-notice.tsx",
+    "../../archive/configure-form.tsx"
+  ],
+  "exclude": ["node_modules", "archive"]
+}

package/.next/standalone/apps/web/verify-models.mjs

@@ -0,0 +1,133 @@
+import fs from 'fs';
+import { embed, generateText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createCohere } from '@ai-sdk/cohere';
+import { createMistral } from '@ai-sdk/mistral';
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { createAnthropic } from '@ai-sdk/anthropic';
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+// Load keys
+const keysContent = fs.readFileSync('../../keys.txt', 'utf8');
+const keys = {};
+keysContent.split('\n').forEach(line => {
+  const match = line.match(/^([A-Z_]+)="?(.*?)"?$/);
+  if (match) keys[match[1]] = match[2];
+});
+
+// Load models
+const modelsJson = JSON.parse(fs.readFileSync('/tmp/gateway_models.json', 'utf8')).data;
+let models = modelsJson.map(m => ({
+  id: m.id,
+  name: m.name || m.id,
+  owned_by: m.owned_by || "unknown",
+  type: m.type || "language",
+  description: m.description || "",
+  context_window: m.context_window || undefined,
+  max_tokens: m.max_tokens || undefined,
+  tags: m.tags || []
+}));
+
+// Filter to just the main providers to speed this up
+const providersToTest = ['google', 'openai', 'anthropic', 'mistral', 'deepseek', 'cohere'];
+models = models.filter(m => providersToTest.includes(m.owned_by));
+
+function getModel(provider, modelId) {
+  const modelName = modelId.includes('/') ? modelId.split('/').slice(1).join('/') : modelId;
+  switch (provider) {
+    case 'google': return createGoogleGenerativeAI({ apiKey: keys.GOOGLE_API_KEY });
+    case 'cohere': return createCohere({ apiKey: keys.COHERE_API_KEY });
+    case 'mistral': return createMistral({ apiKey: keys.MISTRAL_API_KEY });
+    case 'deepseek': return createDeepSeek({ apiKey: keys.DEEPSEEK_API_KEY });
+    case 'anthropic': return createAnthropic({ apiKey: keys.ANTHROPIC_API_KEY });
+    case 'openai': return createOpenAI({ apiKey: keys.OPENAI_API_KEY });
+  }
+  return null;
+}
+
+async function verifyAll() {
+  const validModels = [];
+
+  for (let i = 0; i < models.length; i++) {
+    const model = models[i];
+    const provider = model.owned_by;
+    
+    if (!keys[`${provider.toUpperCase()}_API_KEY`]) {
+      validModels.push(model);
+      continue;
+    }
+
+    const aiProvider = getModel(provider, model.id);
+    const modelName = model.id.includes('/') ? model.id.split('/').slice(1).join('/') : model.id;
+
+    let success = false;
+    let retries = 3;
+
+    while (retries > 0 && !success) {
+      try {
+        if (model.type === 'language') {
+          await generateText({ model: aiProvider(modelName), prompt: 'hi', maxOutputTokens: 16 });
+        } else if (model.type === 'embedding') {
+          const embedder = aiProvider.textEmbeddingModel ? aiProvider.textEmbeddingModel(modelName) : aiProvider.embedding(modelName);
+          await embed({ model: embedder, value: 'test' });
+        }
+        console.log(`✅ SUCCESS: ${model.id}`);
+        validModels.push(model);
+        success = true;
+      } catch (err) {
+        const msg = err.message || '';
+        
+        // Quota exceeded
+        if (msg.includes('429') || msg.includes('Quota exceeded') || msg.includes('rate limit')) {
+          console.log(`⚠️ Rate limit for ${model.id}. Waiting 15s... (${retries} retries left)`);
+          await sleep(15000);
+          retries--;
+          continue;
+        }
+        
+        // Anthropic SDK version mismatch for some models but they are valid in gateway
+        if (provider === 'anthropic' && msg.includes('Unsupported model version v4')) {
+          console.log(`✅ SUCCESS (Assumed valid despite SDK error): ${model.id}`);
+          validModels.push(model);
+          success = true;
+          break;
+        }
+
+        console.log(`❌ ERROR: ${model.id} - ${msg}`);
+        
+        // Parse Google available models
+        if (provider === 'google' && msg.includes('Available models:')) {
+          const match = msg.match(/Available models: (.*)/);
+          if (match) {
+            const availableStr = match[1];
+            const available = availableStr.split(',').map(s => s.trim().replace('models/', ''));
+            
+            for (const a of available) {
+              const newId = `google/${a}`;
+              if (!validModels.find(m => m.id === newId)) {
+                console.log(`   -> Adding replacement model: ${newId}`);
+                validModels.push({ ...model, id: newId, name: a });
+              }
+            }
+          }
+        }
+        break; // break out of retry loop for permanent errors
+      }
+    }
+    
+    // Slight delay to avoid hitting rate limits too quickly
+    await sleep(2000);
+  }
+
+  // Deduplicate by ID
+  const uniqueModels = Array.from(new Map(validModels.map(m => [m.id, m])).values());
+
+  let output = 'import type { GatewayModel } from "./models-cache";\n\n';
+  output += 'export const ALL_MODELS: GatewayModel[] = ' + JSON.stringify(uniqueModels, null, 2) + ';\n';
+  fs.writeFileSync('../../packages/core/src/models-list.ts', output);
+  console.log(`Done! Wrote ${uniqueModels.length} verified models to models-list.ts`);
+}
+
+verifyAll().catch(console.error);

package/.next/standalone/apps/web/vitest.config.ts

@@ -0,0 +1,15 @@
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  // Mirrors the `@/*` path alias in tsconfig, so a module under test can use
+  // the same imports as the app rather than relative paths for testability.
+  resolve: {
+    alias: { '@': fileURLToPath(new URL('.', import.meta.url)) },
+  },
+  test: {
+    include: ['lib/**/*.test.ts', 'app/**/*.test.ts'],
+    exclude: ['node_modules/**', '.next/**'],
+    environment: 'node',
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkup",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "engines": {
     "node": ">=22"
   },