claude-ws 0.4.9-beta.5 → 0.4.9-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-ws",
-  "version": "0.4.9-beta.5",
+  "version": "0.4.9-beta.6",
   "private": false,
   "description": "AI-powered workspace for solo CEOs and indie builders — manage your entire business with AI agents, not just code. Kanban board, code editor, Git integration, claw agent hub, local-first SQLite.",
   "keywords": [

package/src/app/api/sync/minio/pull/route.ts

@@ -98,7 +98,7 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'projectId is required' }, { status: 400 });
     }
 
-    const apiHookUrl = resolveApiHookUrl(undefined, request.nextUrl.hostname);
+    const apiHookUrl = resolveApiHookUrl(undefined, request.nextUrl.hostname, projectId);
     if (!apiHookUrl) {
       return NextResponse.json({ error: 'API_HOOK_URL is not configured on server' }, { status: 500 });
     }

package/src/app/api/sync/minio/push/route.ts

@@ -98,7 +98,7 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'projectId is required' }, { status: 400 });
     }
 
-    const apiHookUrl = resolveApiHookUrl(undefined, request.nextUrl.hostname);
+    const apiHookUrl = resolveApiHookUrl(undefined, request.nextUrl.hostname, projectId);
     if (!apiHookUrl) {
       return NextResponse.json({ error: 'API_HOOK_URL is not configured on server' }, { status: 500 });
     }

package/src/hooks/template/hooks/.env.example

@@ -1,11 +1,12 @@
-# Optional hard override (if set, this value is always used)
-# API_HOOK_URL="http://localhost:5005/api/sync/"
+# Domain template (required)
+# {room_id} (or room_id) will be replaced by PROJECT_ID at runtime.
+API_HOOK_URL_DOMAIN="https://privos-chat-dev.roxane.one/api/v1/internal/rooms/{room_id}/files/"
 
-# Auto-select by environment/host:
-# - localhost/dev -> API_HOOK_URL_LOCAL
-# - domain/prod   -> API_HOOK_URL_DOMAIN
-API_HOOK_URL_LOCAL="http://localhost:5005/api/sync/"
-API_HOOK_URL_DOMAIN="https://privos-chat-dev.roxane.one/api/v1/internal/rooms/room_id/files/"
+# Optional explicit override. If this contains room_id/{room_id}, it is also replaced by PROJECT_ID.
+# API_HOOK_URL="https://privos-chat-dev.roxane.one/api/v1/internal/rooms/{room_id}/files/"
+
+# Optional local fallback for non-domain environments.
+# API_HOOK_URL_LOCAL="http://localhost:5005/api/sync/"
 API_HOOK_API_KEY=
 API_QUEUE_URL="http://localhost:8052"
 # Optional comma-separated extra queue endpoints/base URLs

package/src/hooks/template/hooks/minio-pull-sync.ts

@@ -113,10 +113,12 @@ async function ensurePullDb(): Promise<Database.Database> {
   return sqlite;
 }
 
-async function fetchManifest(folder: string, label: string, allowNotFound = false): Promise<ManifestEntry[]> {
-  console.error(`🔍 Calling API to get manifest for '${label}' (${folder})...`);
+async function fetchManifest(label: string, options?: { root?: "markdown"; allowNotFound?: boolean }): Promise<ManifestEntry[]> {
+  const root = options?.root;
+  const allowNotFound = options?.allowNotFound || false;
+  console.error(`🔍 Calling API to get manifest for '${label}'${root ? ` (root=${root})` : ""}...`);
 
-  const url = buildApiUrl(`manifest?folder=${encodeURIComponent(folder)}`);
+  const url = root ? buildApiUrl(`manifest?root=${encodeURIComponent(root)}`) : buildApiUrl("manifest");
   const response = await fetch(url, { headers: buildApiHeaders() });
 
   if (response.status === 404 && allowNotFound) {
@@ -140,12 +142,9 @@ async function fetchManifest(folder: string, label: string, allowNotFound = fals
 }
 
 async function getQueueCandidates(): Promise<{ candidates: QueueFileCandidate[]; manifestData: ManifestEntry[] }> {
-  const mainPrefix = config.projectId;
-  const markdownPrefix = `markdown/${config.projectId}`;
-
   const [mainManifest, markdownManifest] = await Promise.all([
-    fetchManifest(mainPrefix, "main folder"),
-    fetchManifest(markdownPrefix, "markdown folder", true),
+    fetchManifest("main folder"),
+    fetchManifest("markdown folder", { root: "markdown", allowNotFound: true }),
   ]);
 
   const normalize = (entries: ManifestEntry[], folder: FolderType): QueueFileCandidate[] => (

package/src/lib/api-hook-url.ts

@@ -24,34 +24,44 @@ function readVar(key: string, hookEnvValues?: HookEnvMapLike): string {
   return '';
 }
 
-function shouldUseLocalByHost(hostname?: string): boolean {
-  const fromHost = (hostname || '').toLowerCase();
-  const fromEnvHost = (process.env.HOST || '').toLowerCase();
-  const appUrl = (process.env.API_BASE_URL || process.env.CORS_ORIGIN || '').toLowerCase();
-
-  const localMarkers = ['localhost', '127.0.0.1', '0.0.0.0'];
-  if (fromHost) {
-    return localMarkers.some((marker) => fromHost.includes(marker));
+function hasRoomPlaceholder(value: string): boolean {
+  return /\{room_id\}|room_id/i.test(value);
+}
+
+function resolveRoomTemplate(value: string, roomId?: string): string {
+  const trimmed = trimQuotes(value);
+  if (!hasRoomPlaceholder(trimmed)) {
+    return trimmed;
   }
 
-  const hasLocalEnvHost = localMarkers.some((marker) => fromEnvHost.includes(marker) || appUrl.includes(marker));
-  if (hasLocalEnvHost) return true;
+  const normalizedRoomId = (roomId || '').trim();
+  if (!normalizedRoomId) {
+    return trimmed;
+  }
 
-  return process.env.NODE_ENV !== 'production';
+  return trimmed
+    .replace(/\{room_id\}/gi, normalizedRoomId)
+    .replace(/room_id/gi, normalizedRoomId);
 }
 
-export function resolveApiHookUrl(hookEnvValues?: HookEnvMapLike, hostname?: string): string {
+export function resolveApiHookUrl(hookEnvValues?: HookEnvMapLike, _hostname?: string, roomId?: string): string {
+  const resolvedRoomId = (roomId || readVar('PROJECT_ID', hookEnvValues)).trim();
+  const domainTemplate = readVar('API_HOOK_URL_DOMAIN', hookEnvValues);
+  if (domainTemplate) {
+    return resolveRoomTemplate(domainTemplate, resolvedRoomId);
+  }
+
   const explicit = readVar('API_HOOK_URL', hookEnvValues);
-  if (explicit) return explicit;
+  if (explicit) {
+    return resolveRoomTemplate(explicit, resolvedRoomId);
+  }
 
   const local = readVar('API_HOOK_URL_LOCAL', hookEnvValues);
-  const domain = readVar('API_HOOK_URL_DOMAIN', hookEnvValues);
-
-  if (shouldUseLocalByHost(hostname)) {
-    return local || domain;
+  if (local) {
+    return resolveRoomTemplate(local, resolvedRoomId);
   }
 
-  return domain || local;
+  return '';
 }
 
 /**

package/src/lib/minio-pull-queue.ts

@@ -257,15 +257,15 @@ async function readHookEnv(projectPath: string, fallbackProjectId: string): Prom
     map.set(key, value);
   }
 
-  const apiHookUrl = resolveApiHookUrl(map);
+  const projectId = map.get('PROJECT_ID')?.trim() || fallbackProjectId;
+  const apiHookUrl = resolveApiHookUrl(map, undefined, projectId);
   if (!apiHookUrl) {
-    throw new Error('Missing API_HOOK_URL in project hook .env and process env');
+    throw new Error('Missing API_HOOK_URL/API_HOOK_URL_DOMAIN in project hook .env and process env');
   }
   const apiHookApiKey = map.get('API_HOOK_API_KEY')?.trim()
     || process.env.API_HOOK_API_KEY?.trim()
     || '';
 
-  const projectId = map.get('PROJECT_ID')?.trim() || fallbackProjectId;
   return { apiHookUrl, apiHookApiKey, projectId };
 }
 
@@ -277,10 +277,11 @@ function buildApiHeaders(apiHookApiKey: string): Record<string, string> {
 async function fetchManifest(
   apiHookUrl: string,
   apiHookApiKey: string,
-  folder: string,
-  label: string
+  label: string,
+  options?: { root?: 'markdown' }
 ): Promise<ManifestEntry[]> {
-  const url = buildApiHookEndpoint(apiHookUrl, `manifest?folder=${encodeURIComponent(folder)}`);
+  const endpoint = options?.root ? `manifest?root=${options.root}` : 'manifest';
+  const url = buildApiHookEndpoint(apiHookUrl, endpoint);
   const response = await fetch(url, { headers: buildApiHeaders(apiHookApiKey) });
   if (!response.ok) {
     throw new Error(`Manifest API failed for ${label}: HTTP ${response.status} ${response.statusText}`);
@@ -362,12 +363,9 @@ async function fetchQueueCandidates(
   projectId: string,
   sqlite: Database.Database
 ): Promise<QueueFileCandidate[]> {
-  const targetPrefix = projectId;
-  const markdownPrefix = `markdown/${projectId}`;
-
   const [mainManifest, markdownManifest] = await Promise.all([
-    fetchManifest(apiHookUrl, apiHookApiKey, targetPrefix, 'main folder'),
-    fetchManifest(apiHookUrl, apiHookApiKey, markdownPrefix, 'markdown folder'),
+    fetchManifest(apiHookUrl, apiHookApiKey, 'main folder'),
+    fetchManifest(apiHookUrl, apiHookApiKey, 'markdown folder', { root: 'markdown' }),
   ]);
 
   const normalize = (entries: ManifestEntry[], folder: 'main' | 'markdown'): QueueFileCandidate[] => (
@@ -908,8 +906,8 @@ async function processJob(projectPath: string, projectId: string, job: PendingJo
           const manifestEntry = await fetchManifest(
             hookEnv.apiHookUrl,
             hookEnv.apiHookApiKey,
-            row.folder === 'main' ? hookEnv.projectId : `markdown/${hookEnv.projectId}`,
-            row.folder
+            row.folder,
+            row.folder === 'markdown' ? { root: 'markdown' } : undefined
           );
           const latest = manifestEntry.find((entry) => entry.key === row.fileKey);
           if (!latest) {

package/src/lib/minio-push-queue.ts

@@ -226,15 +226,15 @@ async function readHookEnv(projectPath: string, fallbackProjectId: string): Prom
     values.set(key, value);
   }
 
-  const apiHookUrl = resolveApiHookUrl(values);
+  const projectId = values.get('PROJECT_ID')?.trim() || fallbackProjectId;
+  const apiHookUrl = resolveApiHookUrl(values, undefined, projectId);
   if (!apiHookUrl) {
-    throw new Error('Missing API_HOOK_URL in project hook .env and process env');
+    throw new Error('Missing API_HOOK_URL/API_HOOK_URL_DOMAIN in project hook .env and process env');
   }
   const apiHookApiKey = values.get('API_HOOK_API_KEY')?.trim()
     || process.env.API_HOOK_API_KEY?.trim()
     || '';
 
-  const projectId = values.get('PROJECT_ID')?.trim() || fallbackProjectId;
   return { apiHookUrl, apiHookApiKey, projectId };
 }
 
@@ -339,12 +339,18 @@ async function requestWithoutJsonWithRetry(
   throw new Error(`${label} failed after ${REQUEST_MAX_RETRIES} attempts: ${lastError?.message || 'Unknown error'}`);
 }
 
-async function fetchManifest(apiHookUrl: string, apiHookApiKey: string, folder: string): Promise<ManifestEntry[]> {
-  const url = buildApiHookEndpoint(apiHookUrl, `manifest?folder=${encodeURIComponent(folder)}`);
+async function fetchManifest(
+  apiHookUrl: string,
+  apiHookApiKey: string,
+  label: string,
+  options?: { root?: 'markdown' },
+): Promise<ManifestEntry[]> {
+  const endpoint = options?.root ? `manifest?root=${options.root}` : 'manifest';
+  const url = buildApiHookEndpoint(apiHookUrl, endpoint);
   const payload = await requestJsonWithRetry(
     url,
     { method: 'GET', headers: buildApiHeaders(apiHookApiKey) },
-    `Manifest fetch (${folder})`
+    `Manifest fetch (${label})`
   ) as {
     status?: string;
     data?: unknown;
@@ -352,7 +358,7 @@ async function fetchManifest(apiHookUrl: string, apiHookApiKey: string, folder:
   };
 
   if (payload.status !== 'success' || !Array.isArray(payload.data)) {
-    throw new Error(`Invalid manifest response for ${folder}: ${payload.message || 'Invalid payload'}`);
+    throw new Error(`Invalid manifest response for ${label}: ${payload.message || 'Invalid payload'}`);
   }
 
   return payload.data as ManifestEntry[];
@@ -581,10 +587,12 @@ function enqueueInDb(
 
 export async function enqueueProjectPushSync(projectPath: string, fallbackProjectId: string) {
   const hookEnv = await readHookEnv(projectPath, fallbackProjectId);
-  const [remoteManifest, localFiles] = await Promise.all([
-    fetchManifest(hookEnv.apiHookUrl, hookEnv.apiHookApiKey, hookEnv.projectId),
+  const [mainManifest, markdownManifest, localFiles] = await Promise.all([
+    fetchManifest(hookEnv.apiHookUrl, hookEnv.apiHookApiKey, 'main'),
+    fetchManifest(hookEnv.apiHookUrl, hookEnv.apiHookApiKey, 'markdown', { root: 'markdown' }),
     scanLocalFiles(projectPath, hookEnv.projectId),
   ]);
+  const remoteManifest = [...mainManifest, ...markdownManifest];
 
   const candidates = buildQueueCandidates(hookEnv.projectId, localFiles, remoteManifest);
   const sqlite = await ensurePushQueueDb(projectPath);
@@ -705,7 +713,7 @@ async function uploadByPresignedUrl(url: string, localPath: string): Promise<voi
 
 async function deleteByApiEndpoint(apiHookUrl: string, apiHookApiKey: string, key: string): Promise<void> {
   const encodedKey = encodeURIComponent(key);
-  const deleteUrl = buildApiHookEndpoint(apiHookUrl, `delete?key=${encodedKey}`);
+  const deleteUrl = buildApiHookEndpoint(apiHookUrl, `by-path?key=${encodedKey}`);
   await requestWithoutJsonWithRetry(
     deleteUrl,
     { method: 'DELETE', headers: buildApiHeaders(apiHookApiKey) },

package/src/lib/project-utils.ts

@@ -106,7 +106,7 @@ export async function setupProjectDefaults(projectPath: string, projectId?: stri
         try {
             await access(envPath);
         } catch {
-            const apiBase = resolveApiHookUrl();
+            const apiBase = resolveApiHookUrl(undefined, undefined, projectId);
             const apiHookApiKey = process.env.API_HOOK_API_KEY?.trim() || '';
             const projectIdEnvLine = projectId ? `PROJECT_ID="${projectId}"\n` : '';
             const apiKeyEnvLine = apiHookApiKey ? `API_HOOK_API_KEY="${apiHookApiKey}"\n` : '';