mirror of
https://github.com/multica-ai/multica.git
synced 2026-08-02 18:13:27 +02:00
cac453fe01
* fix(selfhost): read the published host port back from Compose (MUL-5505)
`make selfhost` polled the wrong port when the backend host port was passed
through the environment. Make and Compose disagree on variable precedence: an
assignment in an included makefile (the Makefile `include`s .env) overrides a
real environment variable, while for Compose the environment overrides .env.
Because .env.example ships BACKEND_PORT uncommented, .env always pinned the
recipe's view of the port, so `BACKEND_PORT=9000 make selfhost` published the
stack on 9000 while the health check hammered 8080 for 60s and then reported
"Services are still starting" on a perfectly healthy install. The success
message printed the same wrong backend URL. FRONTEND_PORT had the same
inversion, affecting the printed frontend URL.
Stop re-deriving the host port in the recipe and ask Compose, which is the only
authority on what it published. The wait-and-report block (three port
references per target, duplicated across selfhost and selfhost-build) moves into
scripts/selfhost-wait.sh, which resolves both host ports via `docker compose
port` and falls back to the compose default chain when the stack is not up.
Also fix the input contract: `PORT` was the only port variable documented in
SELF_HOSTING_ADVANCED.md, yet compose read only BACKEND_PORT, so setting the
documented variable was silently ignored. The backend host port mapping now
falls back to `${PORT:-8080}`, matching Makefile and scripts/local-env.sh, and
the docs describe both variables as host ports.
Container-internal ports (8080/3000), the global PORT derivation used by local
dev, and the 127.0.0.1 bindings are unchanged; the default self-host experience
is byte-identical.
Fixes #6145
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): make PORT the real backend port and test the whole chain
Addresses review feedback on #6168.
The first round's root-cause claim was wrong. It said `BACKEND_PORT=9100 make
selfhost` published on 9100 while the health check probed 8080. It does not:
when make drives Compose, Compose inherits make's exported values, so both
sides agree on 8080 and the override is silently dropped instead. Re-measured
through the real recipe, the genuine disagreements were:
- `.env` setting PORT with no BACKEND_PORT: probe followed PORT, Compose
published ${BACKEND_PORT:-8080} — 9100 vs 8080.
- `make selfhost PORT=8080` over a .env with BACKEND_PORT=9100: probe 8080,
Compose published 9100.
Both are the "wrong port variable" defect the GitHub issue names, and reading
the port back from Compose fixes both. The comments and PR text that blamed
make/Compose precedence are corrected.
The PORT fallback added to docker-compose.selfhost.yml was also unreachable:
.env.example shipped BACKEND_PORT=8080 uncommented, so the fallback never
engaged and `SELF_HOSTING_AI.md`'s "edit PORT and FRONTEND_PORT" instruction did
nothing. Pick one contract and apply it everywhere: PORT is the backend port to
edit, BACKEND_PORT/API_PORT/SERVER_PORT are optional aliases that override it.
That is already what Makefile, scripts/local-env.sh, scripts/install.sh and
install.ps1 do; compose and the web dev fallback were the outliers.
- .env.example ships BACKEND_PORT commented out, like its sibling aliases, so
editing PORT works out of the box.
- apps/web/config/runtime-urls.ts walks the same alias chain instead of
reading BACKEND_PORT alone, so `pnpm dev` follows an edited PORT.
- SELF_HOSTING_AI.md and SELF_HOSTING_ADVANCED.md state the contract.
Configuration that cannot take effect is now reported instead of ignored.
scripts/selfhost-preflight.sh warns when an alias in the env file overrides an
edited PORT, and when a port from the shell environment is overridden by the env
file. The Makefile captures the pristine origins before its include, because
afterwards there is no way to tell that `PORT=9000 make selfhost` was asked for.
Tests now cross environment -> make -> compose -> report for real. The docker
stub is no longer told what to publish: on `up` it asks the real
`docker compose config` to interpolate the compose file with the environment the
recipe actually handed it, records that, and answers `port` from the recording.
Verified failing on the old code — with the old recipe and compose file the
suite reports published 8080 against probe 9100, the exact defect.
Co-authored-by: multica-agent <github@multica.ai>
* ci: gate the self-host test on scripts/selfhost-preflight.sh too
The new preflight script was missing from the frontend path filter, so a
change to it alone would skip the test that covers it.
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): honour the full backend port alias chain in Compose
Addresses the second review round on #6168.
The contract this PR documents is
BACKEND_PORT -> API_PORT -> SERVER_PORT -> PORT -> 8080
and Makefile, scripts/local-env.sh, scripts/install.sh, scripts/install.ps1 and
apps/web/config/runtime-urls.ts all implement it. docker-compose.selfhost.yml
implemented only BACKEND_PORT -> PORT -> 8080, so `API_PORT=9100` or
`SERVER_PORT=9200` in .env still published 8080.
That is not only a direct-Compose concern. scripts/install.sh:407 derives its
health-check port from the full chain and then runs this compose file, so an
alias it honours but Compose ignores puts the probe on 9100 while the stack
listens on 8080 — the original #6145 defect, reached through the installer.
- docker-compose.selfhost.yml publishes the full nested chain, verified to
keep the same precedence and the same 8080 default.
- scripts/selfhost-wait.sh's fallback matches, so the degraded path agrees
with what Compose would have published.
- The Makefile captures the pristine origins of API_PORT and SERVER_PORT too,
and the preflight reports them, so no alias can be silently overridden by
the env file while the others are reported.
Tests pin the chain on the boundaries a recipe-level test cannot see, because
Makefile normalises all four aliases into PORT before any recipe runs: a matrix
over the direct Compose path asserts each alias moves the published port with
the right precedence, and every case additionally asserts that
scripts/install.sh's resolver returns the same value Compose published. That
invariant is the one that actually protects the installer.
Verified failing without the fix: with the two-level chain restored the suite
reports `expected 9200 / compose published 8080 / installer resolved 9200`, and
with the alias warnings narrowed it reports the missing API_PORT notice.
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): resolve one winner before reporting ignored port config
Addresses the third review round on #6168.
The preflight walked each alias independently, so it made a separate "wins"
claim per alias. With
PORT=9000
BACKEND_PORT=8000
API_PORT=7000
SERVER_PORT=6000
in .env it announced that BACKEND_PORT, API_PORT and SERVER_PORT each won, when
only BACKEND_PORT=8000 can. Two of the three notices were simply false.
It also compared only same-named shell and file variables, so shadowing across
aliases stayed silent: .env with PORT=8000 and BACKEND_PORT=8000 plus a shell
API_PORT=7000 produced no output at all, even though API_PORT was discarded.
Resolve the winner along the documented chain first — within a variable the env
file beats the environment, then BACKEND_PORT beats API_PORT beats SERVER_PORT
beats PORT — and report only the inputs that winner actually shadows. Output now
names one winning input and lists the rest, whichever variable or source they
came from. An input carrying the winning value is not reported: it is redundant
but the user still gets the port they asked for, so there is nothing to fix.
Tests cover both cases the old logic got wrong: every alias set at once must
yield exactly one winner claim and list the others as unused, and an env-file
alias beating a lower-priority shell alias must be reported. Also asserted that
a redundant same-value alias and a default configuration both stay silent.
Measured against the previous implementation, phrasing aside: with all four
values set it made 3 winner claims where there is now 1, and on the cross-alias
case it printed nothing where API_PORT is now reported.
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): track env-file existence so empty port assignments resolve right
Addresses the fourth review round on #6168.
The Makefile passed only values to the preflight, so the script inferred "the
env file does not set this" from an empty string. An explicit empty assignment is
a different input from an absent one: make lets `BACKEND_PORT=` in the env file
override `BACKEND_PORT=9000` from the environment, and the variable then drops out
of the alias chain instead of setting a port.
With .env holding PORT=8080 and BACKEND_PORT=, invoked as
`BACKEND_PORT=9000 make selfhost`, the stack published 8080 and the health check
probed 8080 — correct — while the preflight announced
the backend host port resolves to 9000 from BACKEND_PORT (environment)
Set but unused: PORT=8080 (.env)
naming the ignored value as the winner and the winning value as unused. A report
that contradicts the startup is worse than no report. FRONTEND_PORT= had the
matching hole: it shadowed the environment, Compose fell back to 3000, and the
preflight said nothing.
The Makefile now captures ENV_FILE_<VAR>_IS_SET from $(origin) alongside the
value, for all five port variables via one $(foreach) instead of hand-written
lines. The preflight treats a variable the file defines as taking the file's
value even when empty, so it shadows the environment, and an empty value never
wins — resolution continues down the chain and falls back to 8080. Inputs the
winner shadows are still listed, including ones shadowed by an empty assignment.
The frontend check mirrors this and now names the port that actually resolved.
Recipe-level tests cover an empty alias over a shell value, every link of the
chain emptied at once, and the frontend equivalent — each asserting the reported
winner, the Compose published port and the probed port all agree. Against the
previous implementation the first case fails with `reported: 9000 / actual: 8080`.
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): installers read the published port; drop the second parser
Addresses all four blockers from the consolidated review on #6168.
1. Both installers probed and printed the wrong port. scripts/install.sh:402 and
scripts/install.ps1 start Compose inheriting the current environment, and
Compose lets that environment outrank .env — but the installers then derived
the probe port and the summary URL from .env alone. Measured on this branch
before the fix, every port variable diverged:
ambient PORT=9100 -> compose 9100, installer 8080
ambient BACKEND_PORT=9200 -> compose 9200, installer 8080
ambient API_PORT=9300 -> compose 9300, installer 8080
ambient SERVER_PORT=9400 -> compose 9400, installer 8080
ambient FRONTEND_PORT=3100 -> compose 3100, installer 3000
Both now read the ports back once with `docker compose port` after `up -d`
and reuse that single result for the health check and the summary. If the
query fails they fail loudly instead of claiming success. The .env-derived
helpers are deleted rather than left beside the new path.
2. The Make preflight is removed entirely, as the review recommended. It
modelled `origin=environment` and `origin=file` but not `command line`, so
`make selfhost BACKEND_PORT=9000` over a .env with API_PORT=7000 announced
7000 while Compose published 9000. That was its fourth wrong report in four
rounds, because it was a second parser of precedence rules — the very thing
this PR removes elsewhere. `docker compose port` is the runtime truth, so the
script, the Makefile captures and the macro are gone.
3. Tests now cover the installer paths that were unguarded. scripts/install.test.sh
gains a `--with-server` matrix (defaults, .env PORT, all four backend aliases,
FRONTEND_PORT, ambient overriding .env for all five, and explicit-empty
fallback) plus a case proving an unresolvable port fails loudly. A new
scripts/install.ps1.test.ps1 drives the same matrix through Start-LocalInstall.
Every case asserts Compose's published port == the probed URL == the printed
URL. Ambient variables are explicitly cleared per case so a runner's own PORT
cannot leak. The Makefile matrix gains the command-line origin cases. CI runs
the PowerShell suite on windows-latest in the always-on installer job, and the
frontend filter now includes both installers.
4. Docs state the real contract: the alias order is shared, but which *source*
wins is per entry point — Compose prefers the environment, make prefers the
included env file, and a make command-line assignment outranks both. The
removed preflight's promise is gone from SELF_HOSTING_AI.md, and the compose
header no longer claims the installer derives its own health-check port.
Verified failing without the fixes: the Bash matrix reports
`[ambient PORT beats .env] compose published 9500 / probed 9100 / printed 9100`
against the old installer, and the PowerShell matrix reports
`printed backend=8080` against an injected summary divergence.
Co-authored-by: multica-agent <github@multica.ai>
* fix(selfhost): keep web dev proxy off frontend port
Co-authored-by: multica-agent <github@multica.ai>
---------
Co-authored-by: Eve <eve@multica-ai.local>
Co-authored-by: multica-agent <github@multica.ai>
310 lines
13 KiB
Makefile
310 lines
13 KiB
Makefile
.PHONY: help makehelp dev server daemon cli multica build test migrate-up migrate-down sqlc seed clean setup start stop check worktree-env setup-main start-main stop-main check-main setup-worktree start-worktree stop-worktree check-worktree db-up db-down db-reset selfhost selfhost-build selfhost-stop
|
|
|
|
MAIN_ENV_FILE ?= .env
|
|
WORKTREE_ENV_FILE ?= .env.worktree
|
|
ENV_FILE ?= $(if $(wildcard $(MAIN_ENV_FILE)),$(MAIN_ENV_FILE),$(if $(wildcard $(WORKTREE_ENV_FILE)),$(WORKTREE_ENV_FILE),$(MAIN_ENV_FILE)))
|
|
|
|
ifneq ($(wildcard $(ENV_FILE)),)
|
|
include $(ENV_FILE)
|
|
endif
|
|
|
|
POSTGRES_DB ?= multica
|
|
POSTGRES_USER ?= multica
|
|
POSTGRES_PASSWORD ?= multica
|
|
POSTGRES_PORT ?= 5432
|
|
PORT := $(or $(BACKEND_PORT),$(API_PORT),$(SERVER_PORT),$(PORT),8080)
|
|
ifeq ($(origin MULTICA_PUBLIC_URL), undefined)
|
|
MULTICA_PUBLIC_URL := http://localhost:$(PORT)
|
|
endif
|
|
FRONTEND_PORT ?= 3000
|
|
FRONTEND_ORIGIN ?= http://localhost:$(FRONTEND_PORT)
|
|
MULTICA_APP_URL ?= $(FRONTEND_ORIGIN)
|
|
DATABASE_URL ?= postgres://$(POSTGRES_USER):$(POSTGRES_PASSWORD)@localhost:$(POSTGRES_PORT)/$(POSTGRES_DB)?sslmode=disable
|
|
NEXT_PUBLIC_API_URL ?= http://localhost:$(PORT)
|
|
NEXT_PUBLIC_WS_URL ?= ws://localhost:$(PORT)/ws
|
|
GOOGLE_REDIRECT_URI ?= $(FRONTEND_ORIGIN)/auth/callback
|
|
MULTICA_SERVER_URL ?= ws://localhost:$(PORT)/ws
|
|
LOCAL_UPLOAD_BASE_URL ?= http://localhost:$(PORT)
|
|
|
|
export
|
|
|
|
MULTICA_ARGS ?= $(ARGS)
|
|
|
|
COMPOSE := docker compose
|
|
|
|
define REQUIRE_ENV
|
|
@if [ ! -f "$(ENV_FILE)" ]; then \
|
|
echo "Missing env file: $(ENV_FILE)"; \
|
|
echo "Create .env from .env.example, or run 'make worktree-env' and use .env.worktree."; \
|
|
exit 1; \
|
|
fi
|
|
endef
|
|
|
|
# Self-hosting requires the Docker Compose CLI plugin (`docker compose`).
|
|
# The self-host compose files use compose-spec syntax (top-level `name:`, no
|
|
# `version:`) that the legacy v1 `docker-compose` standalone cannot parse, so we
|
|
# fail early with an actionable message instead of a cryptic CLI parse error
|
|
# (e.g. "unknown shorthand flag: 'f' in -f") when the plugin is missing or v1.
|
|
# Keep the message short and OS-agnostic: per-OS install steps belong in docs.
|
|
define REQUIRE_COMPOSE
|
|
@if ! compose_version=$$($(COMPOSE) version --short 2>/dev/null); then \
|
|
echo "Docker Compose ('docker compose') was not found."; \
|
|
echo "Self-hosting requires the Compose CLI plugin; legacy 'docker-compose' v1 is not supported."; \
|
|
echo "Install Docker Compose from https://docs.docker.com/compose/install/ and verify with: docker compose version"; \
|
|
exit 1; \
|
|
fi; \
|
|
case "$$compose_version" in \
|
|
1.*|v1.*) \
|
|
echo "'$(COMPOSE)' is legacy Docker Compose v1 ($$compose_version)."; \
|
|
echo "Self-hosting requires the Compose CLI plugin; legacy 'docker-compose' v1 is not supported."; \
|
|
echo "Install Docker Compose from https://docs.docker.com/compose/install/ and verify with: docker compose version"; \
|
|
exit 1; \
|
|
;; \
|
|
esac
|
|
endef
|
|
|
|
# Default target changed from selfhost to help: bare `make` now prints this help
|
|
# instead of launching a full Docker Compose build, which is safer for onboarding.
|
|
.DEFAULT_GOAL := help
|
|
|
|
##@ Help
|
|
|
|
help: ## Show available make targets and common local workflows
|
|
@awk 'BEGIN {FS = ":.*## "; printf "\nUsage:\n make \033[36m<target>\033[0m\n\nQuick start:\n \033[36mmake dev\033[0m Bootstrap the current checkout and start everything\n \033[36mmake check\033[0m Run the full local verification pipeline\n\nCheckout modes:\n Main checkout uses \033[36m.env\033[0m\n Worktrees use \033[36m.env.worktree\033[0m (generate with \033[36mmake worktree-env\033[0m)\n\n"} \
|
|
/^##@/ {printf "\n\033[1m%s\033[0m\n", substr($$0, 5); next} \
|
|
/^[a-zA-Z0-9_.-]+:.*## / {printf " \033[36m%-18s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
|
|
|
|
makehelp: help ## Alias for `make help`
|
|
|
|
# ---------- Self-hosting (Docker Compose) ----------
|
|
##@ Self-hosting
|
|
|
|
selfhost: ## Create .env if needed, then pull and start the official self-hosted images
|
|
$(REQUIRE_COMPOSE)
|
|
@if [ ! -f .env ]; then \
|
|
echo "==> Creating .env from .env.example..."; \
|
|
cp .env.example .env; \
|
|
JWT=$$(openssl rand -hex 32); \
|
|
PGPASS=$$(openssl rand -hex 24); \
|
|
VCSKEY=$$(openssl rand -base64 32); \
|
|
if [ "$$(uname)" = "Darwin" ]; then \
|
|
sed -i '' "s/^JWT_SECRET=.*/JWT_SECRET=$$JWT/" .env; \
|
|
sed -i '' "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$$PGPASS/" .env; \
|
|
sed -i '' -E "s#^(DATABASE_URL=postgres://[^:]+:)[^@]*(@.*)#\1$$PGPASS\2#" .env; \
|
|
sed -i '' "s#^MULTICA_VCS_SECRET_KEY=.*#MULTICA_VCS_SECRET_KEY=$$VCSKEY#" .env; \
|
|
else \
|
|
sed -i "s/^JWT_SECRET=.*/JWT_SECRET=$$JWT/" .env; \
|
|
sed -i "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$$PGPASS/" .env; \
|
|
sed -i -E "s#^(DATABASE_URL=postgres://[^:]+:)[^@]*(@.*)#\1$$PGPASS\2#" .env; \
|
|
sed -i "s#^MULTICA_VCS_SECRET_KEY=.*#MULTICA_VCS_SECRET_KEY=$$VCSKEY#" .env; \
|
|
fi; \
|
|
echo "==> Generated random JWT_SECRET, POSTGRES_PASSWORD, and MULTICA_VCS_SECRET_KEY"; \
|
|
fi
|
|
@echo "==> Pulling official Multica images..."
|
|
@if ! $(COMPOSE) -f docker-compose.selfhost.yml pull; then \
|
|
echo ""; \
|
|
echo "Official images for tag '$${MULTICA_IMAGE_TAG:-latest}' are not published yet."; \
|
|
echo "If this is before the first GHCR release, build from the current checkout:"; \
|
|
echo " make selfhost-build"; \
|
|
exit 1; \
|
|
fi
|
|
@echo "==> Starting Multica via Docker Compose..."
|
|
$(COMPOSE) -f docker-compose.selfhost.yml up -d
|
|
@bash scripts/selfhost-wait.sh official
|
|
|
|
selfhost-build: ## Build backend/web from the current checkout and start the self-hosted stack
|
|
$(REQUIRE_COMPOSE)
|
|
@if [ ! -f .env ]; then \
|
|
echo "==> Creating .env from .env.example..."; \
|
|
cp .env.example .env; \
|
|
JWT=$$(openssl rand -hex 32); \
|
|
PGPASS=$$(openssl rand -hex 24); \
|
|
VCSKEY=$$(openssl rand -base64 32); \
|
|
if [ "$$(uname)" = "Darwin" ]; then \
|
|
sed -i '' "s/^JWT_SECRET=.*/JWT_SECRET=$$JWT/" .env; \
|
|
sed -i '' "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$$PGPASS/" .env; \
|
|
sed -i '' -E "s#^(DATABASE_URL=postgres://[^:]+:)[^@]*(@.*)#\1$$PGPASS\2#" .env; \
|
|
sed -i '' "s#^MULTICA_VCS_SECRET_KEY=.*#MULTICA_VCS_SECRET_KEY=$$VCSKEY#" .env; \
|
|
else \
|
|
sed -i "s/^JWT_SECRET=.*/JWT_SECRET=$$JWT/" .env; \
|
|
sed -i "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$$PGPASS/" .env; \
|
|
sed -i -E "s#^(DATABASE_URL=postgres://[^:]+:)[^@]*(@.*)#\1$$PGPASS\2#" .env; \
|
|
sed -i "s#^MULTICA_VCS_SECRET_KEY=.*#MULTICA_VCS_SECRET_KEY=$$VCSKEY#" .env; \
|
|
fi; \
|
|
echo "==> Generated random JWT_SECRET, POSTGRES_PASSWORD, and MULTICA_VCS_SECRET_KEY"; \
|
|
fi
|
|
@echo "==> Building Multica from the current checkout..."
|
|
$(COMPOSE) -f docker-compose.selfhost.yml -f docker-compose.selfhost.build.yml up -d --build
|
|
@bash scripts/selfhost-wait.sh build
|
|
|
|
selfhost-stop: ## Stop the self-hosted Docker Compose stack
|
|
$(REQUIRE_COMPOSE)
|
|
@echo "==> Stopping Multica services..."
|
|
$(COMPOSE) -f docker-compose.selfhost.yml down
|
|
@echo "✓ All services stopped."
|
|
|
|
# ---------- One-click commands ----------
|
|
##@ One-click
|
|
|
|
setup: ## Prepare the current checkout from its env file: install deps, ensure DB, run migrations
|
|
$(REQUIRE_ENV)
|
|
@echo "==> Using env file: $(ENV_FILE)"
|
|
@echo "==> Installing dependencies..."
|
|
pnpm install
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
@echo "==> Running migrations..."
|
|
cd server && go run ./cmd/migrate up
|
|
@echo ""
|
|
@echo "✓ Setup complete! Run 'make start' to launch the app."
|
|
|
|
start: ## Start backend and frontend for the current checkout and run migrations first
|
|
$(REQUIRE_ENV)
|
|
@echo "Using env file: $(ENV_FILE)"
|
|
@echo "Backend: http://localhost:$(PORT)"
|
|
@echo "Frontend: http://localhost:$(FRONTEND_PORT)"
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
@echo "Running migrations..."
|
|
cd server && go run ./cmd/migrate up
|
|
@echo "Starting backend and frontend..."
|
|
@trap 'kill 0' EXIT; \
|
|
(cd server && go run ./cmd/server) & \
|
|
pnpm dev:web & \
|
|
wait
|
|
|
|
stop: ## Stop backend and frontend processes for the current checkout
|
|
$(REQUIRE_ENV)
|
|
@echo "Stopping services..."
|
|
@-lsof -ti:$(PORT) | xargs kill -9 2>/dev/null
|
|
@-lsof -ti:$(FRONTEND_PORT) | xargs kill -9 2>/dev/null
|
|
@case "$(DATABASE_URL)" in \
|
|
""|*@localhost:*|*@localhost/*|*@127.0.0.1:*|*@127.0.0.1/*|*@\[::1\]:*|*@\[::1\]/*) \
|
|
echo "✓ App processes stopped. Shared PostgreSQL is still running on localhost:$(POSTGRES_PORT)." ;; \
|
|
*) \
|
|
echo "✓ App processes stopped. Remote PostgreSQL was not affected." ;; \
|
|
esac
|
|
|
|
check: ## Run typecheck, TS tests, Go tests, and Playwright E2E for the current checkout
|
|
$(REQUIRE_ENV)
|
|
@ENV_FILE="$(ENV_FILE)" bash scripts/check.sh
|
|
|
|
db-up: ## Start the shared PostgreSQL container used by main and worktrees
|
|
@$(COMPOSE) up -d postgres
|
|
|
|
db-down: ## Stop the shared PostgreSQL container without removing its Docker volume
|
|
@$(COMPOSE) down
|
|
|
|
# Drop + recreate the current env's database, then run all migrations.
|
|
# Use for a clean slate in local dev. Only affects the DB named in
|
|
# ENV_FILE (POSTGRES_DB); the shared postgres container and other
|
|
# worktree DBs are untouched. Refuses to run against a remote host.
|
|
db-reset: ## Drop and recreate the current env's database, then re-run all migrations
|
|
$(REQUIRE_ENV)
|
|
@case "$(DATABASE_URL)" in \
|
|
""|*@localhost:*|*@localhost/*|*@127.0.0.1:*|*@127.0.0.1/*|*@\[::1\]:*|*@\[::1\]/*) ;; \
|
|
*) echo "Refusing to reset: DATABASE_URL points at a remote host."; exit 1 ;; \
|
|
esac
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
@echo "==> Dropping and recreating database '$(POSTGRES_DB)'..."
|
|
@$(COMPOSE) exec -T postgres psql -U $(POSTGRES_USER) -d postgres -v ON_ERROR_STOP=1 \
|
|
-c "DROP DATABASE IF EXISTS \"$(POSTGRES_DB)\" WITH (FORCE);" \
|
|
-c "CREATE DATABASE \"$(POSTGRES_DB)\";"
|
|
@echo "==> Running migrations..."
|
|
cd server && go run ./cmd/migrate up
|
|
@echo ""
|
|
@echo "✓ Database '$(POSTGRES_DB)' reset. Run 'make start' to launch the app."
|
|
|
|
worktree-env: ## Generate .env.worktree with a unique DB name and app ports for this worktree
|
|
@bash scripts/init-worktree-env.sh .env.worktree
|
|
|
|
setup-main: ## Prepare the main checkout using .env
|
|
@$(MAKE) setup ENV_FILE=$(MAIN_ENV_FILE)
|
|
|
|
start-main: ## Start the main checkout using .env
|
|
@$(MAKE) start ENV_FILE=$(MAIN_ENV_FILE)
|
|
|
|
stop-main: ## Stop the main checkout processes defined by .env
|
|
@$(MAKE) stop ENV_FILE=$(MAIN_ENV_FILE)
|
|
|
|
check-main: ## Run the full verification pipeline for the main checkout
|
|
@ENV_FILE=$(MAIN_ENV_FILE) bash scripts/check.sh
|
|
|
|
setup-worktree: ## Ensure .env.worktree exists, then prepare this worktree
|
|
@if [ ! -f "$(WORKTREE_ENV_FILE)" ]; then \
|
|
echo "==> Generating $(WORKTREE_ENV_FILE) with unique ports..."; \
|
|
bash scripts/init-worktree-env.sh $(WORKTREE_ENV_FILE); \
|
|
else \
|
|
echo "==> Using existing $(WORKTREE_ENV_FILE)"; \
|
|
fi
|
|
@$(MAKE) setup ENV_FILE=$(WORKTREE_ENV_FILE)
|
|
|
|
start-worktree: ## Start this worktree using .env.worktree
|
|
@$(MAKE) start ENV_FILE=$(WORKTREE_ENV_FILE)
|
|
|
|
stop-worktree: ## Stop this worktree's backend and frontend processes
|
|
@$(MAKE) stop ENV_FILE=$(WORKTREE_ENV_FILE)
|
|
|
|
check-worktree: ## Run the full verification pipeline for this worktree
|
|
@ENV_FILE=$(WORKTREE_ENV_FILE) bash scripts/check.sh
|
|
|
|
# ---------- Individual commands ----------
|
|
##@ Individual commands
|
|
|
|
dev: ## Bootstrap this checkout end-to-end: create env if needed, ensure DB, migrate, start services
|
|
@bash scripts/dev.sh
|
|
|
|
server: ## Run only the Go server for the current checkout
|
|
$(REQUIRE_ENV)
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
cd server && go run ./cmd/server
|
|
|
|
daemon: ## Restart the local agent daemon using the CLI's stored auth/session
|
|
@$(MAKE) multica MULTICA_ARGS="daemon restart --profile local"
|
|
|
|
cli: ## Run the multica CLI with ARGS or MULTICA_ARGS from source
|
|
@$(MAKE) multica MULTICA_ARGS="$(MULTICA_ARGS)"
|
|
|
|
multica: ## Run the multica CLI entrypoint directly from the Go source tree
|
|
cd server && go run -ldflags "-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.date=$(DATE)" ./cmd/multica $(MULTICA_ARGS)
|
|
|
|
VERSION ?= $(shell git describe --tags --match 'v[0-9]*' --always --dirty 2>/dev/null || echo dev)
|
|
COMMIT ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
|
|
DATE ?= $(shell date -u '+%Y-%m-%dT%H:%M:%SZ')
|
|
|
|
build: ## Build the server, CLI, and migrate binaries into server/bin
|
|
cd server && go build -ldflags "-X main.version=$(VERSION) -X main.commit=$(COMMIT)" -o bin/server ./cmd/server
|
|
cd server && go build -ldflags "-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.date=$(DATE)" -o bin/multica ./cmd/multica
|
|
cd server && go build -o bin/migrate ./cmd/migrate
|
|
|
|
test: ## Run Go tests after ensuring the target DB exists and migrations are applied
|
|
$(REQUIRE_ENV)
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
cd server && go run ./cmd/migrate up
|
|
bash scripts/test-go.sh --race
|
|
|
|
# Database
|
|
##@ Database
|
|
|
|
migrate-up: ## Create the target DB if needed, then apply database migrations
|
|
$(REQUIRE_ENV)
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
cd server && go run ./cmd/migrate up
|
|
|
|
migrate-down: ## Create the target DB if needed, then roll back database migrations
|
|
$(REQUIRE_ENV)
|
|
@bash scripts/ensure-postgres.sh "$(ENV_FILE)"
|
|
cd server && go run ./cmd/migrate down
|
|
|
|
sqlc: ## Regenerate sqlc code
|
|
cd server && sqlc generate
|
|
|
|
# Cleanup
|
|
##@ Cleanup
|
|
|
|
clean: ## Remove build caches, generated binaries, and temp files
|
|
rm -rf server/bin server/tmp
|
|
rm -rf apps/*/.next apps/*/.source apps/*/.expo
|
|
rm -rf apps/*/out apps/*/dist apps/*/dist-electron packages/*/dist
|
|
rm -rf .turbo apps/*/.turbo packages/*/.turbo
|
|
rm -rf apps/*/*.tsbuildinfo packages/*/*.tsbuildinfo
|
|
@echo "✓ Clean complete."
|