Feat/docker deploy

.dockerignore

@@ -0,0 +1,48 @@
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Git
+.git/
+.gitignore
+.gitattributes
+
+# Node
+web/node_modules/
+web/dist/
+web/electron/
+web/.nuxt/
+web/.output/
+
+# Python
+app/__pycache__/
+app/src/__pycache__/
+app/.venv/
+app/.uv/
+**/*.pyc
+**/*.pyo
+**/__pycache__/
+**/.pytest_cache/
+**/.ruff_cache/
+
+# Docker
+docker/data/
+docker/postgresql-16/data/
+docker/redis/data/
+docker/minio/data/
+
+# Docs
+docs/
+/*.md
+*.drawio
+
+# Tests
+app/tests/
+web/src/**/*.test.ts
+web/src/**/*.spec.ts
+
+# Misc
+.claude/
+.superpowers/

.gitignore

@@ -38,4 +38,4 @@ app/artifacts/
 .playwright*
 .snow/
 
-/node_modules/
+/node_modules/docker/.env.production

app/.env.example

@@ -3,12 +3,22 @@ FF_DB_URI=postgresql://root:password@localhost:5432/fileflash
 # DATABASE_URL=postgresql://root:password@localhost:5432/fileflash
 APP_ENV=development
 
+# Required when APP_ENV=production or APP_ENV=prod.
+DEFAULT_ADMIN_USERNAME=administrator
+DEFAULT_ADMIN_EMAIL=admin@fileflash.next
+DEFAULT_ADMIN_PASSWORD=replace-with-32-bytes-or-longer-password
+
 JWT_SECRET_KEY=please-set-at-least-32-bytes-secret-key
 # Optional dedicated HMAC key for token hash persistence.
 # Falls back to JWT_SECRET_KEY when omitted.
 # TOKEN_HASH_SECRET=please-set-at-least-32-bytes-and-different-from-jwt-secret
 ACCESS_TOKEN_EXPIRE_MINUTES=4320
 REFRESH_TOKEN_EXPIRE_DAYS=7
+# Auth risk-control defaults (can be overridden per environment)
+MAX_FAILED_LOGIN_ATTEMPTS=8
+ACCOUNT_LOCK_MINUTES=5
+REGISTER_RATE_LIMIT=12
+LOGIN_RATE_LIMIT=30
 
 REDIS_URL=redis://localhost:6379/0
 # RabbitMQ is optional in this stage, kept for future publisher swap.
@@ -26,6 +36,7 @@ UPLOAD_CHUNK_SIZE_DEFAULT=5242880
 UPLOAD_CHUNK_SIZE_MIN=1048576
 UPLOAD_CHUNK_SIZE_MAX=16777216
 UPLOAD_SINGLE_FILE_SIZE_MAX=5368709120
+UPLOAD_VERIFY_MERGED_OBJECT_HASH=false
 STARRED_ITEMS_LIMIT=20
 UPLOAD_SESSION_TTL_HOURS=24
 UPLOAD_TEMP_PREFIX=tmp
@@ -54,9 +65,12 @@ AGENT_COMPACT_THRESHOLD=0.75
 AGENT_USER_DAILY_LIMIT=50
 AGENT_USER_CONCURRENT_LIMIT=2
 AGENT_STAGING_TTL_SEC=86400
-AGENT_SSE_ENABLED=false
+AGENT_SSE_ENABLED=true
 AGENT_LLM_PROVIDER=anthropic
 AGENT_LLM_MODEL=claude-sonnet-4-6
+AGENT_LLM_PLAN_MAX_TOKENS=8192
+# For Anthropic-compatible providers, e.g. DeepSeek: https://api.deepseek.com/anthropic
+# AGENT_LLM_BASE_URL=
 # AGENT_LLM_API_KEY=
 AGENT_MCP_ENDPOINTS=[]
 

app/README.md

@@ -3,26 +3,26 @@
 Use one command to start backend API and file workers together:
 
 ```bash
-uv run python -m fileflash.scripts.run_with_workers
+uv run fileflash
 ```
 
 Common options:
 
 ```bash
 # custom host/port
-uv run python -m fileflash.scripts.run_with_workers --host 127.0.0.1 --port 8080
+uv run fileflash --host 127.0.0.1 --port 8080
 
 # start multiple worker processes
-uv run python -m fileflash.scripts.run_with_workers --worker-count 2
+uv run fileflash --worker-count 2
 
 # API only (without workers)
-uv run python -m fileflash.scripts.run_with_workers --no-worker
+uv run fileflash --no-worker
 ```
 
 Notes:
 - This runner starts `uvicorn fileflash.main:app` and `python -m fileflash.workers.consumer`.
 - If any subprocess exits, the runner stops all other subprocesses.
-- If your environment resolves project scripts correctly, `uv run fileflash-dev` is equivalent.
+- `uv run fileflash-dev` is kept as a backward-compatible alias.
 
 ## Database Migration Requirement
 
@@ -31,6 +31,6 @@ Before starting API processes, ensure Flyway migrations are fully applied (inclu
 Recommended startup order:
 1. Start PostgreSQL
 2. Run Flyway migrate
-3. Start API (`uv run fileflash`) or runner (`uv run fileflash-dev`)
+3. Start backend (`uv run fileflash`; `uv run fileflash-dev` is also supported)
 
 If the schema is outdated, API startup will fail fast with an explicit compatibility error.

app/pyproject.toml

@@ -19,9 +19,10 @@ dependencies = [
     "sqlalchemy>=2.0.48",
     "uvicorn>=0.42.0",
     "python-multipart>=0.0.24",
+    "anthropic>=0.104.1",
 ]
 [project.scripts]
-fileflash = "fileflash.main:main"
+fileflash = "fileflash.scripts.run_with_workers:main"
 fileflash-dev = "fileflash.scripts.run_with_workers:main"
 
 [dependency-groups]
@@ -50,4 +51,4 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/fileflash"]
+packages = ["src/fileflash"]

app/src/fileflash/agents/__init__.py

@@ -14,9 +14,10 @@
     ToolCall,
     ToolRouter,
 )
-from .runtime import ExecuteRunner, PlanRunner, SubagentRunner
+from .runtime import AgentJobCanceled, ExecuteRunner, PlanRunner, SubagentRunner
 
 __all__ = [
+    "AgentJobCanceled",
     "AgentEvent",
     "CheckpointStore",
     "ContextBudget",

app/src/fileflash/agents/harness/__init__.py

@@ -6,6 +6,7 @@
 from .policy import PolicyDecision, PolicyGuard
 from .prompt import PromptBuildRequest, PromptBuilder
 from .router import ToolCall, ToolRouter
+from .tool_registry import REGISTRY, ToolContext, ToolRegistry, ToolSpec
 
 __all__ = [
     "AgentEvent",
@@ -20,6 +21,10 @@
     "PolicyGuard",
     "PromptBuildRequest",
     "PromptBuilder",
+    "REGISTRY",
     "ToolCall",
+    "ToolContext",
+    "ToolRegistry",
     "ToolRouter",
+    "ToolSpec",
 ]

app/src/fileflash/agents/harness/ask.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ...repositories import AgentInboxMessageRepository
+from .event_bus import AgentEventBus, AgentEventEnvelope, AgentEventStream
+
+
+class AskTimedOut(Exception):
+    def __init__(self, *, ask_id: int) -> None:
+        super().__init__(f"Ask {ask_id} timed out")
+        self.ask_id = ask_id
+
+
+class AskProtocol:
+    def __init__(
+        self,
+        *,
+        db: AsyncSession,
+        event_bus: AgentEventBus,
+        job_id: int,
+    ) -> None:
+        self._db = db
+        self._bus = event_bus
+        self._job_id = job_id
+        self._repo = AgentInboxMessageRepository(db)
+        self._waiters: dict[int, asyncio.Future[Any]] = {}
+        self._sub_ctx = None
+        self._sub_stream: AgentEventStream | None = None
+        self._sub_task: asyncio.Task[None] | None = None
+
+    async def start(self) -> None:
+        self._sub_ctx = self._bus.subscribe(job_id=self._job_id)
+        self._sub_stream = await self._sub_ctx.__aenter__()
+        self._sub_task = asyncio.create_task(self._listen())
+
+    async def aclose(self) -> None:
+        if self._sub_task is not None:
+            self._sub_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._sub_task
+        if self._sub_ctx is not None:
+            await self._sub_ctx.__aexit__(None, None, None)
+        for future in self._waiters.values():
+            if not future.done():
+                future.cancel()
+
+    async def ask(
+        self,
+        *,
+        prompt: str,
+        schema: dict[str, Any],
+        timeout_sec: float,
+    ) -> Any:
+        msg = await self._repo.create_ask(
+            job_id=self._job_id,
+            payload={"prompt": prompt, "schema": schema, "timeoutSec": timeout_sec},
+        )
+        await self._db.commit()
+
+        ask_id = int(msg.inbox_message_id)
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[Any] = loop.create_future()
+        self._waiters[ask_id] = future
+
+        await self._bus.publish(
+            AgentEventEnvelope(
+                job_id=self._job_id,
+                event_type="agent.ask",
+                payload={
+                    "messageId": str(ask_id),
+                    "prompt": prompt,
+                    "schema": schema,
+                    "timeoutSec": timeout_sec,
+                },
+                emitted_at=datetime.now(UTC),
+            )
+        )
+
+        try:
+            value = await asyncio.wait_for(future, timeout=timeout_sec)
+        except TimeoutError as exc:
+            await self._repo.mark_timed_out(
+                inbox_message_id=ask_id,
+                answered_at=datetime.now(UTC),
+            )
+            await self._db.commit()
+            raise AskTimedOut(ask_id=ask_id) from exc
+        finally:
+            self._waiters.pop(ask_id, None)
+
+        await self._repo.mark_answered(
+            inbox_message_id=ask_id,
+            answered_at=datetime.now(UTC),
+        )
+        await self._db.commit()
+        return value
+
+    async def _listen(self) -> None:
+        assert self._sub_stream is not None
+        while True:
+            try:
+                envelope = await self._sub_stream.next(timeout=None)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                continue
+            if envelope.event_type != "agent.inbox.reply":
+                continue
+            reply_to = envelope.payload.get("replyTo")
+            if reply_to is None:
+                continue
+            try:
+                ask_id = int(reply_to)
+            except (TypeError, ValueError):
+                continue
+            future = self._waiters.get(ask_id)
+            if future is None or future.done():
+                continue
+            future.set_result(envelope.payload.get("value"))
+
+
+__all__ = ["AskProtocol", "AskTimedOut"]