Runs live, versioned Python application objects on one VM, with a suite of apps: projects, notes, tasks, files and more.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-object-server.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-object-server.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-object-server.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 signup: the person chooses the password and name on the confirm page 83c7aa6 2 weeks, 5 days ago History
status.md · 10.6 KB · 187 lines

Status

DBBASIC Object Server is ready for controlled staging, internal app dogfooding, and invited-user apps behind browser login with permission enforcement on. It is not ready to expose arbitrary code execution to untrusted public users.

Usable Now

  • Single-VM ASGI server behind a reverse proxy
  • Python object execution for operator-controlled objects
  • Source reads, gated source writes, source versions, rollback, and source

change history

  • Object state, logs, log rotation/compression, files readback, and metadata
  • TSV-backed collection records with UUIDv4 IDs by default
  • Schema metadata, validation, field permissions, schema history, and rollback
  • Collection record change history
  • Event publishing, event retention, subscriptions, and callback delivery state
  • Package manifest discovery, dry-runs, gated installs, install changelogs,

restore points, and restore API

  • A small installable system-dashboard package for public staging visibility
  • A small installable admin-write-probe package for testing object state writes

and admin-token-gated collection record writes on a narrow public route

  • File-backed accounts, users, self-service session inspection/revocation, and

permission subjects

  • Password credentials (scrypt, stored outside user records), admin password

set/reset routes, opt-in password login, session cookies with origin checks, a built-in browser /login + /logout flow with per-identifier login lockout, request identity injected into object execution (request["_identity"]), and a Django-style shell CLI for bootstrap and user management

  • Permission policy storage, check API, audit mode, readiness status, row

filters, field redaction, opt-in enforcement, and rollout gates for recovery, identity, and policy safety

  • A documented starter policy (object_permission_store.starter_policy_payload)

and a completed audit-then-enforce rollout on public staging: enforcement is ON at object.dbbasic.com with public grants for the public pages and probe reads, registered-user grants for object execution and probe writes, and admin-role bypass

  • Request size limits, request concurrency limits, execution concurrency limits,

rate limits, wall-clock timeout path, and health/capacity metrics

  • Token-gated admin status with detailed health, inventory, capability flags,

package posture, and permission readiness for Scroll/operator dashboards

  • Token-gated admin object inspection for Scroll/operator source, state, logs,

versions, metadata, files, and source-change views without exposing broad /objects execution routes through the reverse proxy

  • Token-gated admin file inventory, download, and gated write routes for

Scroll/operator file views; upload/delete remain deployment-disabled unless DBBASIC_ENABLE_FILE_WRITES=true

  • Token-gated admin collection and schema inspection for Scroll/operator

collection, record, changelog, schema, and schema-version views without exposing broad write-capable /collections* or /schemas* routes

  • Token-gated admin record create/update/delete and schema replace/rollback

aliases so Scroll/operator screens can run the data loop (define schema, write records, validate, audit, emit events) through the narrow admin surface

  • Token-gated daemon status with read-only scheduler, queue, event delivery,

retention, and cleanup posture for Scroll/operator dashboards

  • Token-gated scheduler and queue control APIs for trusted operator screens,

using the same daemon-compatible TSV state

  • An MCP endpoint (POST /api/mcp, JSON-RPC 2.0) so AI agents can run the

full object and data loops through the same gated admin surface, with per-agent session identity in the audit trail

  • Opt-in site routing (DBBASIC_ENABLE_SITE_ROUTES) for clean website URLs:

convention (/about -> site_about), a site_routes records table with {param}/{param:uuid} patterns, and site_404, all resolving through the policy-enforced execution path

  • Multi-domain hosting on one server: a site_hosts records table maps each

domain to its own object prefix, home, and 404, with host-scoped route patterns, so many websites share one runtime, identity store, and audit trail. Be aware: users and credentials are ONE shared store across all domains on an instance — one login works everywhere, and per-site member separation is done with accounts and policy grants, not separate user tables. Domains needing fully separate identity belong on their own server instance.

  • Schema-driven global search (GET /api/search + the global_search MCP

tool): collections opt in with search.fields, and results respect permission row filters and field redaction per caller

  • A twelve-package application suite (projects with self-serve sharing

grants, notes, tasks with an enforced status lifecycle, contacts, articles, links, events, files, templates, timers, the shell, and the collaboration layer of comments/feed/notifications) — every app is schema + permission rules + at most one page object, with no app-specific server code (see app-packages.md)

  • Per-user AI: write-only provider key storage, model choice per request,

and POST /api/ai/chat — an AI turn that can call a caller-chosen subset of the MCP tools with the caller's own credentials, so an AI acting for a user is never more powerful than the user (see shell-and-ai.md)

  • User file storage with per-user disk quotas, where downloads are

authorized against each file's metadata record — owner rows, public links, and project sharing govern files like any other record

  • Realtime push over websockets (/ws): the notification bell and every

app-page list update the instant a record changes — in another tab, by another user, or by an agent — over one shared socket, permission- filtered so you only receive events for records you may read; the durable event log stays as the poll fallback

  • A themeable design system delivered as objects: semantic token roles,

swappable themes (/appearance), a shared component vocabulary, and a persistent app-shell nav (/nav) contributed to every page by a package

  • Runtime backups, restore helpers, deployment checks, GitHub Actions tests, and

a working public staging deployment shape

Good Fit Today

  • Local development
  • Private or internal apps
  • Public pages backed by reviewed objects
  • Controlled staging on one VM
  • Scroll/API integration work
  • Migrating small Django/PostgreSQL data into object records and schemas
  • Package authoring and install dry-runs
  • Self-service signup, email verification and password reset (browser

forms at /signup, /verify, /reset), off by default and refusing to turn on while any rule gives every signed-in user unscoped access, while enforcement is off, or while email cannot be sent

Not Ready Yet

  • Open signup where strangers can run arbitrary Python code
  • Public source writes
  • Enforcement-on as the shipped default (it is opt-in per deployment; staging

has it on)

  • Policy checks for the admin-token-only surfaces (identity, permissions,

schemas, daemon, events, packages stay admin-gated by design)

  • Session admin gates are implemented, but opt-in with

DBBASIC_ENABLE_SESSION_ADMIN_GATES=true

  • CPU and memory isolation for untrusted object code
  • Fully managed event delivery/admin control API
  • Long media work specifically. There IS a background-job runtime now

(app-runner: submit → run record → worker → result, with money held at submission and settled on completion, and an asynchronous submit/poll path for jobs that outlive a pass), and scheduled AI text runs through it in production. What it has no handler for yet is image/video generation, transcodes, PDF text extraction and thumbnails.

  • Cluster correctness claims
  • No lot or serial tracking on stock. Inventory is valued at a moving

weighted average (object_stock.weighted_average_cost_cents), which is accepted under GAAP and IFRS and needs nothing the append log does not already carry. FIFO — and any question of the form "which specific units are still on the shelf", including expiry-date picking and serial recalls — needs cost layers that stock_moves has no dimension for.

Next Work

The application suite is ported (see app-packages.md), the single-VM installer and quickstart exist (scripts/install.sh, quickstart.md), and realtime push over websockets is live (/ws, permission-filtered — see http-api-contract.md and asgi-realtime-direction.md; the nav's notification bell already updates on push).

Four items that were on this list have since shipped and are recorded here rather than deleted, because a plan that only ever grows is one nobody trusts: the generative renderer (schema → list/detail/form, now the default surface for most collections rather than a per-app page), the background-job runtime (app-runner — submit → run record → worker → result, with holds and settlement, and asynchronous submit/poll for jobs that outlive a pass), metered billing (app-billing wallets and usage), and the remaining q9 apps (messaging, email, finance, catalog, billing all exist).

The remaining work is platform capability, in rough priority order:

  1. Extend realtime further: object source/state/version rooms

(/ws/objects/{id}) so the dashboard goes live, organic notification triggers (a task assigned to you mints a notification) plus click-to-dismiss on the bell, and a shared broker before scaling past one uvicorn worker. (The notification bell and every app-page list are already live over /ws.)

  1. Write-level project sharing ($writable_projects) and a per-family

"builder role" so agents and collaborators can be scoped below admin.

  1. Add CPU/memory isolation and a better worker boundary for untrusted code.
  2. A JSON API for signup and password reset (browser forms only today,

see Self-Service Signup in http-api-contract.md).

  1. Media generation through the runner: the engine, the async submit/poll

loop and per-image/per-second pricing (unit_prices) are in place; what is missing is a handler for an image or video provider, and the quality gate that decides whether what came back is usable before it is charged for.

Release Rule

The first production release should be honest about the boundary: one VM, operator-controlled objects, server-enforced permissions, backups, logs, versions, packages, and Scroll integration. Distributed cluster behavior and public untrusted code execution should stay explicitly experimental until they have separate hardening and tests.