tailcam 1.8.3__tar.gz

tailcam-1.8.3/.dockerignore

@@ -0,0 +1,23 @@
+# Build context hygiene for the TailCam image.
+.git
+.github
+**/__pycache__/
+**/*.pyc
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+
+# Node — the web UI is rebuilt inside the image's web stage.
+web-ui/node_modules/
+
+# Tooling caches and tests aren't needed in the image.
+tests/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Repo-level docs sources (the in-app wiki markdown lives under web-ui/ and is
+# bundled by the web build, so it is NOT excluded here).
+docs/

tailcam-1.8.3/.github/workflows/desktop.yml

@@ -0,0 +1,123 @@
+name: desktop-app
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "src/tailcam/desktop/**"
+      - "src/tailcam/cli.py"
+      - "tests/test_desktop.py"
+      - "pyproject.toml"
+      - ".github/workflows/desktop.yml"
+  pull_request:
+    paths:
+      - "src/tailcam/desktop/**"
+      - "src/tailcam/cli.py"
+      - "tests/test_desktop.py"
+      - "pyproject.toml"
+      - ".github/workflows/desktop.yml"
+
+jobs:
+  linux-core:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: pytest tests/test_desktop.py -q
+
+  # The reference GUI platform: real pystray/pywebview stack under xvfb.
+  linux-gui:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: System GUI deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xvfb dbus-x11 python3-venv python3-gi python3-gi-cairo \
+            gir1.2-gtk-3.0 gir1.2-ayatanaappindicator3-0.1
+          sudo apt-get install -y gir1.2-webkit2-4.1 || sudo apt-get install -y gir1.2-webkit2gtk-4.1
+      - name: Install (system python sees gi)
+        run: |
+          python3 -m venv --system-site-packages ~/gui-venv
+          ~/gui-venv/bin/pip install ".[desktop]"
+      - name: Backend + diagnostics checks
+        run: |
+          xvfb-run -a ~/gui-venv/bin/tailcam app --check
+          ~/gui-venv/bin/tailcam app --smoke
+          ~/gui-venv/bin/python -c "
+          from tailcam.desktop.linux_desktop import gui_diagnostics
+          rows = gui_diagnostics()
+          assert all(ok for ok, *_ in rows), rows
+          print('all GI probes ok:', [label for _, label, _ in rows])
+          "
+      - name: Real tray runs under xvfb
+        run: |
+          set +e
+          timeout 10 xvfb-run -a dbus-launch ~/gui-venv/bin/tailcam app --no-window
+          code=$?
+          set -e
+          test "$code" = 124  # stayed alive until timeout = the tray ran
+      - name: Launcher entries round-trip
+        run: |
+          ~/gui-venv/bin/tailcam app install --autostart
+          test -f ~/.local/share/applications/tailcam.desktop
+          test -f ~/.local/share/icons/hicolor/512x512/apps/tailcam.png
+          test -f ~/.config/autostart/tailcam-tray.desktop
+          grep -q "Exec=.*tailcam.* app" ~/.local/share/applications/tailcam.desktop
+          ~/gui-venv/bin/tailcam app uninstall
+          test ! -f ~/.local/share/applications/tailcam.desktop
+
+  # The real-Mac gate: generates and validates the actual .app on macOS.
+  macos-smoke:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install ".[desktop]"
+      - name: Create TailCam.app
+        run: tailcam app install
+      - name: Validate bundle
+        run: |
+          plutil -lint ~/Applications/TailCam.app/Contents/Info.plist
+          codesign --verify --deep ~/Applications/TailCam.app
+          test -x ~/Applications/TailCam.app/Contents/MacOS/TailCam
+          python -c "
+          from pathlib import Path
+          import struct
+          icns = (Path.home() / 'Applications/TailCam.app/Contents/Resources/TailCam.icns').read_bytes()
+          assert icns[:4] == b'icns' and struct.unpack('>I', icns[4:8])[0] == len(icns)
+          print('icns ok,', len(icns), 'bytes')
+          "
+      - name: Headless self-test
+        run: |
+          tailcam app --check
+          tailcam app --smoke
+
+  # Windows smoke gate: shortcut generation + backends + headless self-test.
+  windows-smoke:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install ".[desktop]"
+      - name: Backend + smoke checks
+        run: |
+          tailcam app --check
+          tailcam app --smoke
+      - name: Shortcut round-trips
+        shell: pwsh
+        run: |
+          tailcam app install --autostart
+          $lnk = "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\TailCam.lnk"
+          if (-not (Test-Path $lnk)) { throw "shortcut not created" }
+          $run = (Get-ItemProperty "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run").TailCam
+          if (-not $run) { throw "autostart Run key missing" }
+          tailcam app uninstall
+          if (Test-Path $lnk) { throw "shortcut not removed" }

tailcam-1.8.3/.github/workflows/docker-publish.yml

@@ -0,0 +1,68 @@
+name: Publish Docker image
+
+# Build the multi-arch TailCam image and publish it to the GitHub Container
+# Registry (GHCR) at ghcr.io/<owner>/tailcam.
+#
+# - push to main           -> :latest, :main, :sha-<short>
+# - push a tag vX.Y.Z      -> :X.Y.Z, :X.Y, :sha-<short>
+# - manual run             -> via the Actions tab
+#
+# Uses the built-in GITHUB_TOKEN — no secrets to configure. The first successful
+# run creates the package; make it public in the repo's Packages settings if you
+# want anonymous `docker pull`.
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository_owner }}/tailcam
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU (multi-arch)
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Derive image tags & labels
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=sha,format=short
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

tailcam-1.8.3/.github/workflows/pypi-publish.yml

@@ -0,0 +1,47 @@
+name: Publish to PyPI
+
+# Trusted Publishing — no PyPI token in GitHub secrets.
+#
+# One-time setup (https://pypi.org/manage/account/publishing/):
+#   PyPI project name:  tailcam
+#   Owner:              FactShin
+#   Repository:         TailCam
+#   Workflow name:      pypi-publish.yml
+#   Environment:        pypi
+#
+# Then create a GitHub Release (tag vX.Y.Z) or run this workflow manually.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  pypi:
+    name: Build and publish
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/tailcam/
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: |
+          pip install --upgrade build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

tailcam-1.8.3/.github/workflows/tests.yml

@@ -0,0 +1,63 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: tests-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # conftest.py sets this too; explicit here so nothing ever touches hardware.
+  TAILCAM_SYNTHETIC: "1"
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check src tests
+      - run: mypy src/tailcam
+
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      # The integration tests exercise the HomeKit (HAP-python) and MQTT extras.
+      - run: pip install -e ".[dev,homekit,mqtt]"
+      - run: pytest -q
+
+  # Windows: the platform-specific layers (installer invariants, service
+  # registration, desktop shortcut, self-update) plus the API surface. The
+  # camera/V4L2 and timing-sensitive capture suites are Linux-only by nature.
+  test-windows:
+    runs-on: windows-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: pip install -e ".[dev]"
+      # test_desktop.py is POSIX-only by nature (launcher entries, .app bundle)
+      # and runs in the desktop-app workflow's linux-core/macos jobs.
+      - run: >-
+          pytest -q tests/test_windows.py tests/test_installer_script.py
+          tests/test_service_control.py tests/test_update.py
+          tests/test_hostinfo.py tests/test_version.py tests/test_api.py
+          tests/test_storage.py tests/test_cluster.py tests/test_mcp.py

tailcam-1.8.3/.gitignore

@@ -0,0 +1,25 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.db
+*.db-wal
+*.db-shm
+.DS_Store
+
+# web-ui (Node). The BUILT dashboard at src/anycam/web/spa/ IS committed so
+# pip installs ship it; only Node working dirs are ignored.
+web-ui/node_modules/
+web-ui/dist/
+web-ui/.vite/
+
+# browser extensions — assembled packages and Safari converter output
+browser-extensions/safari/.build/
+browser-extensions/safari/TailCamCompanion/

tailcam-1.8.3/Dockerfile

@@ -0,0 +1,56 @@
+# syntax=docker/dockerfile:1
+#
+# TailCam container image. Multi-stage: build the web UI with Node, then ship a
+# slim Python runtime with Tailscale, OpenCV/ffmpeg libs, and the app installed.
+# See docs/docker.md (or the in-app Docs → "Docker" page) for usage.
+
+# ---- Stage 1: build the React dashboard ----
+FROM node:22-slim AS web
+WORKDIR /app/web-ui
+COPY web-ui/package.json web-ui/package-lock.json ./
+RUN npm ci
+COPY web-ui/ ./
+# Vite emits to ../src/tailcam/web/spa (OUT_DIR in vite.config.ts).
+RUN npm run build
+
+# ---- Stage 2: Python runtime ----
+FROM python:3.12-slim AS runtime
+
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    TAILCAM_DATA_DIR=/data \
+    TAILCAM_CONFIG_DIR=/config
+
+# Runtime libraries: OpenCV (headless) needs libglib2.0-0; ffmpeg for timelapse
+# encoding; curl/ca-certs to install Tailscale; iptables/iproute2 for tailscaled
+# kernel networking.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libglib2.0-0 \
+        ffmpeg \
+        curl \
+        ca-certificates \
+        iptables \
+        iproute2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Tailscale (tailscale CLI + tailscaled). TailCam shells out to `tailscale serve`.
+RUN curl -fsSL https://tailscale.com/install.sh | sh
+
+WORKDIR /app
+COPY pyproject.toml README.md ./
+COPY src/ ./src/
+# Use the freshly built dashboard from the web stage so the image always matches
+# source (overwrites the committed copy under src/tailcam/web/spa).
+COPY --from=web /app/src/tailcam/web/spa ./src/tailcam/web/spa
+RUN pip install .
+
+COPY docker/entrypoint.sh /usr/local/bin/tailcam-entrypoint
+RUN chmod +x /usr/local/bin/tailcam-entrypoint
+
+# Persist the database/media, the config, and Tailscale node state.
+VOLUME ["/data", "/config", "/var/lib/tailscale"]
+
+# Local/LAN HTTP port. Tailnet access goes over tailscaled, not a published port.
+EXPOSE 8088
+
+ENTRYPOINT ["/usr/local/bin/tailcam-entrypoint"]

tailcam-1.8.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TailCam contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.