gipity 1.1.16 → 1.1.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. package/README.md +58 -75
  2. package/dist/adopt-cwd.js +2 -13
  3. package/dist/api.js +26 -44
  4. package/dist/auth.js +1 -1
  5. package/dist/banner.js +3 -7
  6. package/dist/catalog.js +8 -7
  7. package/dist/commands/add.js +26 -9
  8. package/dist/commands/approval.js +1 -1
  9. package/dist/commands/ask.js +112 -0
  10. package/dist/commands/bug.js +5 -5
  11. package/dist/commands/build.js +10 -35
  12. package/dist/commands/credits.js +3 -3
  13. package/dist/commands/doctor.js +7 -8
  14. package/dist/commands/email.js +6 -56
  15. package/dist/commands/generate.js +4 -4
  16. package/dist/commands/init.js +40 -30
  17. package/dist/commands/key.js +1 -1
  18. package/dist/commands/load.js +2 -12
  19. package/dist/commands/logs.js +2 -2
  20. package/dist/commands/memory.js +5 -17
  21. package/dist/commands/notify.js +1 -1
  22. package/dist/commands/page-eval.js +55 -38
  23. package/dist/commands/page-inspect.js +6 -6
  24. package/dist/commands/page-screenshot.js +51 -54
  25. package/dist/commands/page-test.js +188 -14
  26. package/dist/commands/payments.js +2 -2
  27. package/dist/commands/project.js +66 -15
  28. package/dist/commands/realtime.js +96 -4
  29. package/dist/commands/records.js +4 -6
  30. package/dist/commands/sandbox.js +2 -3
  31. package/dist/commands/skill.js +50 -22
  32. package/dist/commands/status.js +7 -9
  33. package/dist/commands/test.js +2 -2
  34. package/dist/commands/token.js +4 -4
  35. package/dist/commands/workflow.js +45 -8
  36. package/dist/config.js +22 -6
  37. package/dist/flag-aliases.js +75 -18
  38. package/dist/help-skills.js +2 -2
  39. package/dist/hooks/capture-runner.js +5 -3
  40. package/dist/index.js +1616 -1498
  41. package/dist/knowledge.js +24 -21
  42. package/dist/login-flow.js +4 -4
  43. package/dist/net.js +91 -0
  44. package/dist/opencode-setup.js +2 -2
  45. package/dist/page-fixtures.js +3 -3
  46. package/dist/project-setup.js +2 -3
  47. package/dist/prompts.js +1 -1
  48. package/dist/realtime-bench.js +12040 -0
  49. package/dist/relay/agent-token.js +1 -1
  50. package/dist/relay/daemon.js +0 -1
  51. package/dist/relay/setup.js +13 -2
  52. package/dist/setup.js +11 -12
  53. package/dist/sync.js +3 -3
  54. package/dist/utils.js +1 -1
  55. package/package.json +10 -4
  56. package/dist/commands/agent.js +0 -251
  57. package/dist/commands/chat.js +0 -137
  58. package/dist/commands/claude.js +0 -1056
  59. package/dist/commands/plan.js +0 -93
package/dist/knowledge.js CHANGED
@@ -20,7 +20,6 @@ Templates:
20
20
  - \`3d-world\` - Multiplayer world, 3D sandbox, shooter, exploration, virtual showroom (Three.js + Rapier + Colyseus)
21
21
  - \`api\` - Backend service, webhook, data pipeline, chatbot, cron job - no frontend
22
22
  - \`karaoke-captions\` - Forced-alignment app - karaoke captions, subtitle timing, language learning, dubbing alignment
23
- - \`outreach-agent\` - AI outreach / drip-email / lifecycle funnel - move a list of people through stages (sign up, activate, pay) with personalized, human-approved emails on an auto-cadence and a self-improving agent that learns from your edits
24
23
  - \`paid-app\` - App that charges users money - SaaS subscription, paid membership, digital product store, "Pro" upgrade, paywalled content (Stripe one-time + subscriptions)
25
24
  - \`notify-demo\` - App that sends push notifications / alerts / reminders to users' phones or desktops - web push, PWA notifications, "notify me when..." features
26
25
  When unsure, default to \`web-simple\`. After adding the template, edit the generated files, then \`gipity deploy dev\`.
@@ -28,35 +27,36 @@ Only skip this on a build request if the user explicitly says not to.
28
27
 
29
28
  Hidden types (do NOT suggest unsolicited - use only when the user explicitly asks for that domain):
30
29
  - \`app-itsm\` - IT Service Management app (helpdesk, ticketing, incident management).
31
- - \`monitor\` - Account-wide observability dashboard - auto-installed; rarely picked manually.
30
+ - \`monitor\` - The Gipity account web app, served by Gipity itself - not something to install into a project.
31
+ - \`outreach-agent\` - AI outreach / drip-email / lifecycle funnel - move a list of people through stages (sign up, activate, pay) with personalized, human-approved emails on an auto-cadence and a self-improving agent that learns from your edits
32
32
 
33
33
  Kits are reusable building blocks added to an existing app, not whole templates - their files land in \`src/packages/<name>/\`:
34
34
  - \`gipity add realtime\` - Multiplayer / presence / shared state - channels, host election, server-persisted sync. Engine-agnostic; works in any app.
35
35
  - \`gipity add web-vision-mediapipe\` - On-device camera vision - gesture recognition, body pose, object detection. Runs fully client-side via MediaPipe Tasks; no server, no upload. Web only.
36
36
  - \`gipity add web-vision-detect\` - High-accuracy object detection in the browser - YOLOX (Apache-2.0) on ONNX Runtime Web, WebGPU with WASM fallback. 80 COCO classes, three speed/accuracy presets, or bring your own custom-trained YOLO/YOLOX ONNX model. Client-side; no server, no upload. Web only.
37
37
  - \`gipity add chatbot\` - Drop-in chatbot - configurable persona, scope guardrails, static knowledge (20k budget), streaming responses. Headless engine + bubble widget; bring your own UI if you want. Works in any app.
38
- - \`gipity add audio-align\` - Audio + lyrics -> word-level timing JSON. Demucs vocal isolation + MMS_FA forced alignment, runs as a Modal L4 GPU job (~$0.01 per 3-min song). For karaoke captions, subtitling, language learning, dubbing alignment.
38
+ - \`gipity add audio-align\` - Audio + lyrics -> word-level timing JSON. Demucs vocal isolation + MMS_FA forced alignment, runs as a Gipity Jobs GPU job on an L4 (~$0.01 per 3-min song). For karaoke captions, subtitling, language learning, dubbing alignment.
39
39
  - \`gipity add i18n\` - Multi-language for web apps - language picker, locale persistence, RTL, plural/translation lookup. Scaffolds src/js/strings.js and wires it up; move your copy there and read it with t('key'). Web only.
40
40
  - \`gipity add contacts\` - Source-agnostic contact data layer for lead-gen/CRM apps: import people from LinkedIn CSV + Gmail + pasted lists, resolve duplicates into one person while keeping EVERY value from every source with provenance (multi-valued attributes, never overwrites). Exact email/URL auto-merge; fuzzy name+company goes to a human merge-review queue (reversible). Re-imports detect job changes and emit signals. User-definable tags, full-text search, and a transactional event spine. Ships backend functions + migrations. Needs a database (web-fullstack/api template).
41
41
  - \`gipity add stripe\` - Charge your app's end-users for one-time purchases and subscriptions via Stripe. Owner connects their own Stripe account through Gipity-hosted onboarding (no API keys to paste); money lands in their account, Gipity takes a small platform fee. Ships a buy-button / pricing component, a subscription-status helper for gating UI, a webhook-verified fulfillment function, and the payments/subscriptions tables. The platform brokers checkout + signature-verified webhooks. Needs a database (web-fullstack/api template).
42
42
  - \`gipity add notify\` - Web push notifications for any web app, including iOS home-screen web apps (iOS 16.4+). The platform owns the VAPID keys, encryption, and delivery — no keys to paste, no crypto, no server. Ships a <gipity-notify-button>, a service worker, and a PWA manifest; the device subscribes itself and self-heals stale subscriptions. Send from a function with the injected notify() service (one flat credit per send, owner-billed) or test with \`gipity notify test\`. Works in any template — no database required.
43
- - \`gipity add servicenow\` - Use ServiceNow tables as a data source: OAuth (client-credentials) authenticated polling pull into a local Postgres mirror (sn_records, any table, configurable), plus write-back into ServiceNow via the Table API. Optional real-time sync layers a ServiceNow Business Rule + Script Include on top, pushing changes to a webhook the instant they happen. Ships a cron workflow for the pull cycle, sn-pull/sn-write/sn-webhook functions, and setup scripts that automate the ServiceNow-side configuration. Needs a database (web-fullstack/api template).`;
43
+ - \`gipity add servicenow\` - Use ServiceNow tables as a data source: OAuth (client-credentials) authenticated polling pull into a local Postgres mirror (sn_records, any table, configurable), plus write-back into ServiceNow via the Table API. Optional real-time sync layers a ServiceNow Business Rule + Script Include on top, pushing changes to a webhook the instant they happen. Ships a cron workflow for the pull cycle, sn-pull/sn-write/sn-webhook functions, and setup scripts that automate the ServiceNow-side configuration. Needs a database (web-fullstack/api template).
44
+ - \`gipity add leaderboard\` - Leaderboards for any game: high scores or best times, each board declared in a migration with its rankings (all-time, daily, weekly, monthly, seasons), an optional tiebreak score, and server-side plausibility checks (score bounds, official rulesets, checkpoint splits, per-player rate limits, an optional minimum game version). Around-me and friends views (friends matched by Steam id), attached replays, owner moderation (review rejected runs, remove, ban, reset, purge), and a user_deleted hook that erases the entries of a player who deletes their account. Works from a web game or any native client over HTTPS, e.g. a Godot game signed in with Steam. Needs a database (web-fullstack/api template).`;
44
45
  export const SKILLS_CONTENT = `# Gipity Integration
45
46
 
46
- Gipity is the cloud platform your project runs on - hosting, databases, deployment, file storage, code execution, workflows, and monitoring. Gip is the cloud agent that runs on Gipity.
47
+ Gipity is the cloud platform your project runs on - hosting, databases, deployment, file storage, code execution, workflows, and monitoring.
47
48
 
48
- Prefer the cheapest option that works - CLI and sandbox are instant and free, app services are runtime HTTP calls, \`gipity chat\` burns LLM tokens:
49
+ Prefer the cheapest option that works - CLI and sandbox are instant and free, app services are runtime HTTP calls, and a model call (\`gipity ask\`) costs tokens:
49
50
 
50
- 1. CLI commands (fast, no agent overhead). The \`gipity\` CLI covers add, deploy, db, fn, logs, browser, sync, memory, skill, email, and more. All commands support \`--json\`. You can send email yourself - \`gipity email send\` goes out as the agent from \`gipity@gipity.ai\` with no setup or API keys (\`gipity skill read email\`); don't build a \`mailto:\` workaround or reach for an SMTP library.
51
+ 1. CLI commands (fast, no agent overhead). The \`gipity\` CLI covers add, deploy, db, fn, logs, page, sync, memory, skill, email, and more. All commands support \`--json\`.
51
52
  2. Cloud sandbox via \`gipity sandbox run\` - Docker container with pre-installed tools for media (ffmpeg, ImageMagick, sox), documents (pandoc, LibreOffice), and data (pandas, matplotlib, sqlite3). Run \`gipity skill read sandbox-tools\` for the full toolkit. No network from inside the sandbox - fetch what you need before sending it in.
52
- 3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location, push notifications (Gipity Notify - \`gipity add notify\`, send from a function with the injected \`notify()\`; see \`app-notify\`). Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|sound|music>\` or \`gipity chat\` - direct generation always bills you (the owner), regardless of any service \`billing_mode\` (that setting only governs the deployed app's runtime calls; never flip it just to create assets). \`gipity generate\` saves to a generic file in the current directory by default (e.g. \`./generated.png\`) - pass \`-o <path>\` to write it straight into your source tree so it deploys (e.g. \`gipity generate image "hero banner" -o src/assets/images/hero.png\`) instead of generating at cwd and moving it.
53
- 4. Delegate to Gip (\`gipity chat "<task>"\`) - only when the work genuinely needs agent reasoning or a tool not in the CLI, sandbox, or app services. Required for: Twitter/X search, Gmail, calendar, push notifications, video understanding, audio source isolation, cross-model second opinions, multi-step orchestration. Don't use \`gipity chat\` for anything the sandbox can do - it's slower and burns tokens.
53
+ 3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location, push notifications (Gipity Notify - \`gipity add notify\`, send from a function with the injected \`notify()\`; see \`app-notify\`). Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|sound|music>\` - direct generation always bills you (the owner), regardless of any service \`billing_mode\` (that setting only governs the deployed app's runtime calls; never flip it just to create assets). \`gipity generate\` saves to a generic file in the current directory by default (e.g. \`./generated.png\`) - pass \`-o <path>\` to write it straight into your source tree so it deploys (e.g. \`gipity generate image "hero banner" -o src/assets/images/hero.png\`) instead of generating at cwd and moving it. For a quick model answer while you work - summarize a log, extract fields, describe a screenshot, a second opinion from a different model - use \`gipity ask "<question>"\`: one call, no history or tools, any model (\`--model sonnet\`, \`--model openai\`), text files with \`--file <path>\` (\`--file -\` for stdin), images with \`--image <path>\`, and a JSON answer with \`--schema '<json schema>'\`.
54
54
 
55
55
  You are the developer. Write files in this directory - Gipity's editor hooks (installed by \`gipity init\` into Claude Code, Grok, Codex, and opencode) auto-sync them to Gipity. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.
56
56
 
57
57
  ## Use first-party services before reaching outside
58
58
 
59
- Gipity ships first-party services for what apps usually pull from third parties - auth, location/geocoding, LLM, image/audio/video generation, transcription, file uploads, realtime, web push notifications (Gipity Notify - no VAPID keys, no Firebase/OneSignal; works on iOS home-screen web apps), and email (send as the agent via \`gipity email send\`, or from a deployed app's function with the injected \`email()\` service - \`services: ['email']\`, no SMTP/SendGrid/Nodemailer). Before calling an external API or adding an npm package for one of these, check \`gipity skill list\` for a match. First-party services need no API keys, cost less, and keep data in-house. Reach outside only when the catalog has no equivalent - and say so when you do.
59
+ Gipity ships first-party services for what apps usually pull from third parties - auth, location/geocoding, LLM, image/audio/video generation, transcription, file uploads, realtime, web push notifications (Gipity Notify - no VAPID keys, no Firebase/OneSignal; works on iOS home-screen web apps), and email (from a deployed app's function with the injected \`email()\` service - \`services: ['email']\`, no SMTP/SendGrid/Nodemailer; check it with \`gipity email test <to>\`). Before calling an external API or adding an npm package for one of these, check \`gipity skill list\` for a match. First-party services need no API keys, cost less, and keep data in-house. Reach outside only when the catalog has no equivalent - and say so when you do.
60
60
 
61
61
  ## Don't guess Gipity facts - look them up
62
62
 
@@ -78,7 +78,9 @@ Gipity is an opinionated platform with its own best-practice stack, and that sta
78
78
 
79
79
  When a user asks for a foreign stack ("build it in React", "use MS SQL Server", "set up Firebase auth"), don't silently comply and don't argue the app down. Build it the Gipity way and reassure them: Gipity has its own opinionated stack and best practices, it's what makes apps here fast to build and deploy, and you'll use it to make their app great. Say it briefly and warmly, then get building - the result satisfies the *intent* behind the request (a great hiking app, a working CRM) without the named technology.
80
80
 
81
- The one exception is app-level libraries the user imports into their own \`src/\` code - Three.js, Rapier, Phaser, MediaPipe, a charting or animation library. Those are fine. The opinionation is about the *platform* layer (framework, backend, database, styling system, hosting, auth, services), not every npm package.
81
+ **Native games and apps are the other exception.** When the client is a native program (a Godot, Unity or Unreal game, a Steam or desktop build, a mobile app), Gipity is its backend, not its frontend: don't rebuild the client as a web page. Put the backend in its own folder (for Godot, \`backend/\` with a \`.gdignore\`), run \`gipity add api\`, and follow the \`steam-game\` skill: \`gipity project auth app\` lets players sign in with Steam or as guests without a Gipity account, the client calls functions over HTTPS (the Gipity Godot addon, https://github.com/GipityAI/registry/tree/main/examples/godot, wraps this), and \`gipity add leaderboard\` adds leaderboards.
82
+
83
+ The other exception is app-level libraries the user imports into their own \`src/\` code - Three.js, Rapier, Phaser, MediaPipe, a charting or animation library. Those are fine. The opinionation is about the *platform* layer (framework, backend, database, styling system, hosting, auth, services), not every npm package.
82
84
 
83
85
  ## Build loop
84
86
 
@@ -106,8 +108,8 @@ mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <s
106
108
 
107
109
  ## CLI quick reference
108
110
 
109
- Key commands: \`gipity add <template|kit>\`, \`gipity brand set --emoji <e>|--color <hex>\` (regenerate the app's icons + social share card), \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` — never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
110
- Rename for findability: \`gipity project rename <name>\` renames the current project's display name (the slug and deployed URLs never change); \`gipity chat rename <title>\` renames the current chat's tab title. Both are the display label users scan to switch between tabs — retitle a chat when the conversation clearly shifts to a new topic (sparingly, not every turn), and keep every project/chat title SHORT: 2-4 words, ≤40 characters, no trailing punctuation (e.g. "Stripe checkout", "Tetris game").
111
+ Key commands: \`gipity add <template|kit>\`, \`gipity brand set --emoji <e>|--color <hex>\` (regenerate the app's icons + social share card), \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` - never hardcode keys), \`gipity skill read <name>\`.
112
+ Rename for findability: \`gipity project rename <name>\` renames the current project's display name (the slug and deployed URLs never change); it's the label users scan in Monitor and \`gipity project\`, so keep it SHORT: 2-4 words, at most 40 characters, no trailing punctuation (e.g. "Stripe checkout", "Tetris game").
111
113
  Pull an existing remote project local (given its URL/slug): \`mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <slug>\` (adopts the matching project and syncs files down - this is the "clone").
112
114
  Move whole apps in/out: \`gipity save\` (export this project as a portable \`.gip\` bundle), \`gipity load <file.gip | github:owner/repo>\` (import as a NEW project; \`--inspect\` to preview), \`gipity github connect\` (1-2 click GitHub access for imports). Porting a Vercel/Replit/Lovable app? Load the \`app-import\` skill first.
113
115
  For deterministic text questions (letter/word counts, substring occurrences, nth word/char, anagrams), use \`gipity text analyze "<text>"\` - local and instant, no sandbox or LLM needed.
@@ -120,7 +122,7 @@ Tests are isolated, not run against your live DB: \`gipity test\` points \`ctx.f
120
122
 
121
123
  ## Hit friction on the platform? Report it in real time
122
124
 
123
- When *the Gipity platform itself* fights you — a CLI command errors or behaves unexpectedly, a doc/skill is wrong or missing, a deploy/template/kit/service/sandbox misbehaves — file a bug report the moment it happens, **even if you found a workaround and kept going.** Capturing it in the moment (with the real cause fresh) beats us mining it out of transcripts later.
125
+ When *the Gipity platform itself* fights you - a CLI command errors or behaves unexpectedly, a doc/skill is wrong or missing, a deploy/template/kit/service/sandbox misbehaves - file a bug report the moment it happens, **even if you found a workaround and kept going.** Capturing it in the moment (with the real cause fresh) beats us mining it out of transcripts later.
124
126
 
125
127
  \`\`\`
126
128
  gipity bug report --category <cli|deploy|template|kit|db|docs|skill|service|sandbox|other> \\
@@ -131,10 +133,10 @@ gipity bug report --category <cli|deploy|template|kit|db|docs|skill|service|sand
131
133
 
132
134
  - **Severity:** S1 blocker (no workaround) · S2 major (costly workaround) · S3 minor (easy workaround) · S4 friction (papercut).
133
135
  - **summary** ≤ 7 words; **detail** as succinct as possible (a few sentences, not a transcript).
134
- - **Never include PII or user data** (emails, names, secrets, tokens, prompt/file contents) — describe the platform problem in the abstract.
136
+ - **Never include PII or user data** (emails, names, secrets, tokens, prompt/file contents) - describe the platform problem in the abstract.
135
137
  - File it for *platform* problems, not your own mistakes or the app's own bugs. One report per distinct problem.
136
138
  - Reports go to a review queue for the team to triage into fixes; see what you've filed with \`gipity bug list\`.
137
- - Filed one by mistake? Withdraw it yourself: \`gipity bug retract <report-id> [--reason "<why>"]\` — works while it's still queued (status new/triaged). Never file a second report asking a human to close the first.
139
+ - Filed one by mistake? Withdraw it yourself: \`gipity bug retract <report-id> [--reason "<why>"]\` - works while it's still queued (status new/triaged). Never file a second report asking a human to close the first.
138
140
 
139
141
  ## Tool output is complete and synchronous
140
142
 
@@ -144,7 +146,7 @@ Every tool call returns its full output with that call. There is no output buffe
144
146
 
145
147
  This directory is the app root - it holds \`.gipity.json\` (and \`gipity.yaml\` for backends) and is already your cwd, so run app commands here. Don't \`cd\` to a git root (\`git rev-parse --show-toplevel\`): when the app is nested in a larger repo that resolves outside the app.
146
148
 
147
- Write files locally - Gipity's editor hooks (installed into Claude Code, Grok, Codex, and opencode by \`gipity init\`) auto-push every save to Gipity and auto-pull remote changes (images, audio from \`gipity chat\`) before each turn. Use \`gipity sync\` if things get out of sync (or if the hooks aren't installed - \`gipity status --repair-hooks\` re-enables them). Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
149
+ Write files locally - Gipity's editor hooks (installed into Claude Code, Grok, Codex, and opencode by \`gipity init\`) auto-push every save to Gipity and auto-pull remote changes (sandbox outputs, restored versions) before each turn. Use \`gipity sync\` if things get out of sync (or if the hooks aren't installed - \`gipity status --repair-hooks\` re-enables them). Deletes are safe - \`gipity file rollback <datetime>\` undoes a tree, \`gipity file restore <path> <version>\` a single file.
148
150
 
149
151
  To keep local-only material (research clones, scratch data, vendored references) in the project directory without syncing or deploying it, list it in a \`.gipityignore\` at the project root - gitignore-style, one pattern per line, \`#\` comments. Ignored paths are invisible to sync in both directions; anything that already synced before being ignored stays on the server until you delete it.
150
152
 
@@ -185,23 +187,24 @@ App development skills:
185
187
  - \`app-database\` - app Postgres database: migrations, the db helper, transactions, table permissions
186
188
  - \`app-debugging\` - debug a deployed app: page inspect/eval, screenshots, function logs
187
189
  - \`app-development\` - functions, database, and API
188
- - \`app-import\` - import apps from GitHub/.gip bundles (incl. Vercel/Replit/Lovable porting) and export any project as a portable .gip - app_import tool, gipity save/load
190
+ - \`app-import\` - import apps from GitHub/.gip bundles (incl. Vercel/Replit/Lovable porting) and export any project as a portable .gip - gipity load/save, gipity github connect
189
191
  - \`app-records\` - Gipity Records: declared tables → validated CRUD, provenance, workflows, auto UI
190
192
  - \`app-testing\` - testing deployed app functions (ctx.fn.call/callAs, the per-file test DB)
191
193
  - \`deploy\` - the deploy pipeline & gipity.yaml manifest
192
194
  - \`jobs\` - long-running CPU + GPU compute jobs (Python / Node / bash)
193
195
  - \`realtime-scheduled-app\` - recipe: realtime presence/messages + DB function + scheduled poster, end-to-end
196
+ - \`steam-game\` - native/Steam/Godot games: Steam + guest sign-in, the Godot addon, leaderboards
194
197
  - \`web-app-basics\` - coding guidelines, file structure, HTML/CSS/JS patterns
195
198
  - \`web-ui-patterns\` - default Gipity look (theme tokens) + web UI recipes - feeds, copy-to-clipboard
196
199
 
197
200
  Kit skills (reusable building blocks - \`gipity add <kit>\`):
198
201
  - \`audio-align\` - the audio-align kit: forced alignment of audio + lyrics into word-level timing JSON
199
202
  - \`chatbot\` - the chatbot kit: persona + scope guardrails + static knowledge, bubble widget or headless engine
203
+ - \`leaderboard\` - game leaderboards: high scores or times, daily/weekly/monthly/season boards, tiebreaks, replays, cheat checks, bans
200
204
 
201
205
  Other key skills:
202
- - \`email\` - sending email as the agent from gipity@gipity.ai (no setup/keys) — plus Gmail-thread replies, HTML formatting, images
203
- - \`sandbox-tools\` - cloud sandbox capabilities and pre-installed tools
204
- - \`tts\` - agent-side speech tools (different from the \`app-tts\` HTTP service)`;
206
+ - \`email\` - sending email from a deployed app with the email() service or a workflow notify step (no setup/keys), gipity email test/log, HTML formatting, images
207
+ - \`sandbox-tools\` - cloud sandbox capabilities and pre-installed tools`;
205
208
  export const DEFINITION_OF_DONE = `## Definition of done (build tasks)
206
209
  1. \`gipity deploy dev\` succeeds and you have a live URL.
207
210
  2. \`gipity page inspect <url>\` returns no console errors and the page loads (HTTP 200, no blank screen). (\`gipity deploy dev --inspect\` covers 1 and 2 in one command.)
@@ -32,7 +32,7 @@ export function warnBeforeCodeIfUnexpectedNewAccount(isNewUser, email, indent =
32
32
  if (!newAccountWouldBeUnexpected(email, priorAuth))
33
33
  return;
34
34
  const config = getConfig();
35
- console.log(`${indent}${warning(`No existing Gipity account for ${email} — entering the code will CREATE a new one.`)}`);
35
+ console.log(`${indent}${warning(`No existing Gipity account for ${email}: entering the code will CREATE a new one.`)}`);
36
36
  if (config) {
37
37
  console.log(`${indent}${muted(`This directory is linked to project ${config.projectSlug} (account ${config.accountSlug}). If you meant to log into that account, stop and re-check the email before entering the code.`)}`);
38
38
  }
@@ -46,11 +46,11 @@ export function warnIfUnexpectedNewAccount(isNewUser, email, priorAuth, indent =
46
46
  if (!newAccountWouldBeUnexpected(email, priorAuth))
47
47
  return;
48
48
  const config = getConfig();
49
- console.log(`${indent}${warning(`Logged into a NEW, empty account for ${email} — no prior account existed for this email.`)}`);
49
+ console.log(`${indent}${warning(`Logged into a NEW, empty account for ${email}: no prior account existed for this email.`)}`);
50
50
  if (config) {
51
- console.log(`${indent}${muted(`This directory is linked to project ${config.projectSlug} (account ${config.accountSlug}), which the new account does not own — project / skill / sync commands will fail with "not found".`)}`);
51
+ console.log(`${indent}${muted(`This directory is linked to project ${config.projectSlug} (account ${config.accountSlug}), which the new account does not own: project / skill / sync commands will fail with "not found".`)}`);
52
52
  }
53
- console.log(`${indent}${muted('If you expected an existing account, run: gipity status — then gipity login again with the correct email.')}`);
53
+ console.log(`${indent}${muted('If you expected an existing account, run gipity status, then gipity login again with the correct email.')}`);
54
54
  }
55
55
  /** Prompt for email + 6-digit code, persist the tokens, and return the new
56
56
  * auth. Exits the process on empty input or a bad token (the caller can't
package/dist/net.js ADDED
@@ -0,0 +1,91 @@
1
+ import http from 'http';
2
+ /**
3
+ * Outbound networking setup for the CLI process: honor the standard proxy
4
+ * environment variables, and make a failed request say where it was going and
5
+ * why.
6
+ *
7
+ * Node's fetch() ignores HTTP_PROXY / HTTPS_PROXY unless the process starts with
8
+ * NODE_USE_ENV_PROXY=1, so in a sandbox whose only way out is a proxy (curl
9
+ * works, it reads those vars) every command died with a bare "fetch failed"
10
+ * that named neither the host nor the cause (cli#191). Node 24 can switch the
11
+ * same built-in proxy support on at runtime with http.setGlobalProxyFromEnv(),
12
+ * which also respects NO_PROXY.
13
+ */
14
+ const PROXY_VARS = { 'https:': ['HTTPS_PROXY', 'https_proxy'], 'http:': ['HTTP_PROXY', 'http_proxy'] };
15
+ /** The proxy URL the environment configures (credentials stripped): the one
16
+ * for `protocol` requests, or any when no protocol is given. */
17
+ export function configuredProxy(env = process.env, protocol) {
18
+ const vars = protocol === 'https:' || protocol === 'http:'
19
+ ? PROXY_VARS[protocol]
20
+ : [...PROXY_VARS['https:'], ...PROXY_VARS['http:']];
21
+ for (const k of vars) {
22
+ const v = env[k];
23
+ if (!v)
24
+ continue;
25
+ try {
26
+ const u = new URL(v);
27
+ return `${u.protocol}//${u.host}`;
28
+ }
29
+ catch {
30
+ return v;
31
+ }
32
+ }
33
+ return null;
34
+ }
35
+ /** Route fetch()/http(s) through the env-configured proxy. Returns whether the
36
+ * proxy is now in effect (false when none is configured, or this Node predates
37
+ * runtime proxy support - the network error then says how to enable it). */
38
+ export function enableEnvProxy(env = process.env) {
39
+ if (!configuredProxy(env))
40
+ return false;
41
+ const set = http.setGlobalProxyFromEnv;
42
+ if (typeof set !== 'function')
43
+ return env.NODE_USE_ENV_PROXY === '1';
44
+ set(env);
45
+ return true;
46
+ }
47
+ /** Turn undici's bare `TypeError: fetch failed` into one naming the target
48
+ * origin and the underlying cause (DNS, refused, reset, proxy...). Keeps the
49
+ * `fetch failed` prefix, the TypeError type and the original `cause`, so
50
+ * callers that branch on them still work. Only the origin is named: presigned
51
+ * URLs carry credentials in their query string. */
52
+ export function describeFetchError(err, input, proxyActive, env = process.env) {
53
+ if (!(err instanceof TypeError) || err.message !== 'fetch failed')
54
+ return err;
55
+ let origin = 'the server';
56
+ let protocol;
57
+ try {
58
+ const url = new URL(input instanceof Request ? input.url : String(input));
59
+ origin = url.origin;
60
+ protocol = url.protocol;
61
+ }
62
+ catch { /* keep the generic name */ }
63
+ const cause = err.cause;
64
+ const why = cause?.code && cause.message && !cause.message.includes(cause.code)
65
+ ? `${cause.code}: ${cause.message}`
66
+ : cause?.message || cause?.code || 'no further detail';
67
+ const proxy = configuredProxy(env, protocol);
68
+ const route = proxy && proxyActive ? ` via proxy ${proxy}` : '';
69
+ let hint = '';
70
+ if (proxy && !proxyActive) {
71
+ hint = ` A proxy is configured (${proxy}) but this Node version can't apply it at runtime: re-run with NODE_USE_ENV_PROXY=1, or use Node 24+.`;
72
+ }
73
+ else if (!proxy) {
74
+ hint = ' Check the network; if outbound traffic must go through a proxy, set HTTPS_PROXY.';
75
+ }
76
+ return new TypeError(`fetch failed: could not reach ${origin}${route} (${why}).${hint}`, { cause: cause ?? err });
77
+ }
78
+ /** Install both behaviors for this process. Call once, before any request. */
79
+ export function installNetworking() {
80
+ const proxyActive = enableEnvProxy();
81
+ const base = globalThis.fetch;
82
+ globalThis.fetch = async function fetchWithContext(input, init) {
83
+ try {
84
+ return await base(input, init);
85
+ }
86
+ catch (err) {
87
+ throw describeFetchError(err, input, proxyActive);
88
+ }
89
+ };
90
+ }
91
+ //# sourceMappingURL=net.js.map
@@ -94,7 +94,7 @@ export function ensureOpencodePluginInstalled() {
94
94
  return true;
95
95
  mkdirSync(join(opencodeConfigDir(), 'plugins'), { recursive: true });
96
96
  copyFileSync(src, dest);
97
- console.log('Installed the Gipity plugin for opencode (models + session capture).');
97
+ console.error('Installed the Gipity plugin for opencode (models + session capture).');
98
98
  return true;
99
99
  }
100
100
  catch {
@@ -160,7 +160,7 @@ export async function ensureOpencodeModelToken() {
160
160
  const res = await post('/auth/agent-tokens', { name: `opencode models on ${hostname()}`, expiresInDays: MODEL_TOKEN_EXPIRY_DAYS });
161
161
  const stored = {
162
162
  token: res.data.token,
163
- guid: res.data.shortGuid,
163
+ guid: res.data.short_guid,
164
164
  mintedAt: new Date().toISOString(),
165
165
  };
166
166
  mkdirSync(dirname(OPENCODE_TOKEN_FILE), { recursive: true, mode: 0o700 });
@@ -58,9 +58,9 @@ export function assertLocalAsset(flag, localPath) {
58
58
  const root = getProjectRoot() ?? process.cwd();
59
59
  const elsewhere = findByBasename(root, basename(localPath)).filter(p => p !== abs);
60
60
  const found = elsewhere.length
61
- ? `\nThat file DOES exist here — pass this path instead:\n${elsewhere.map(p => ` ${flag} ${relative(process.cwd(), p) || p}`).join('\n')}`
61
+ ? `\nThat file DOES exist here. Pass this path instead:\n${elsewhere.map(p => ` ${flag} ${relative(process.cwd(), p) || p}`).join('\n')}`
62
62
  : `\nNothing named "${basename(localPath)}" under ${root} either. Generate a frame with \`gipity generate image "<description>" -o ${localPath}\`, or check the path.`;
63
- throw new Error(`${flag} ${localPath}: no such file — looked for ${abs} (relative paths resolve against the current directory, ${process.cwd()}).${found}`);
63
+ throw new Error(`${flag} ${localPath}: no such file. Looked for ${abs} (relative paths resolve against the current directory, ${process.cwd()}).${found}`);
64
64
  }
65
65
  /** Upload a local file to the app's public file store and return its URL. */
66
66
  export async function uploadPublicFixture(projectGuid, localPath, flag = '--fixture') {
@@ -116,7 +116,7 @@ export function assertCameraFile(localPath) {
116
116
  const ext = localPath.slice(localPath.lastIndexOf('.')).toLowerCase();
117
117
  if (CAMERA_EXTS.includes(ext))
118
118
  return;
119
- throw new Error(`--camera ${basename(localPath)}: unsupported file type "${ext || '(none)'}" — the camera feed must be an image or video (${CAMERA_EXTS.join(', ')}).\n` +
119
+ throw new Error(`--camera ${basename(localPath)}: unsupported file type "${ext || '(none)'}": the camera feed must be an image or video (${CAMERA_EXTS.join(', ')}).\n` +
120
120
  `A still image is played as a looping single-frame feed, which is what a gesture/pose/object model needs.\n` +
121
121
  `No frame to hand? Generate one: gipity generate image "a hand making a closed fist, palm to camera, plain background"`);
122
122
  }
@@ -18,7 +18,6 @@ export async function finalizeLocalProject(opts) {
18
18
  projectGuid: opts.projectGuid,
19
19
  projectSlug: opts.projectSlug,
20
20
  accountSlug: opts.accountSlug,
21
- agentGuid: opts.agentGuid,
22
21
  conversationGuid: null,
23
22
  apiBase: getApiBaseOverride() || DEFAULT_API_BASE,
24
23
  ignore: [...DEFAULT_SYNC_IGNORE],
@@ -40,7 +39,7 @@ export async function finalizeLocalProject(opts) {
40
39
  projectSlug: opts.projectSlug,
41
40
  });
42
41
  if (sub.changed.length) {
43
- console.log(muted(`Resolved template vars in ${sub.changed.length} file${sub.changed.length > 1 ? 's' : ''}.`));
42
+ console.error(muted(`Resolved template vars in ${sub.changed.length} file${sub.changed.length > 1 ? 's' : ''}.`));
44
43
  }
45
44
  for (const u of sub.unresolved) {
46
45
  console.warn(muted(` ${u.path}: unknown placeholder${u.tokens.length > 1 ? 's' : ''} ${u.tokens.join(', ')}`));
@@ -54,7 +53,7 @@ export async function finalizeLocalProject(opts) {
54
53
  try {
55
54
  const result = await sync({
56
55
  interactive: opts.interactive ?? false,
57
- progress: createProgressReporter(),
56
+ progress: opts.json ? undefined : createProgressReporter(),
58
57
  });
59
58
  applied = result.applied;
60
59
  }
package/dist/prompts.js CHANGED
@@ -42,7 +42,7 @@ export const HIDDEN_TEMPLATE_PICKER = HIDDEN_TEMPLATES
42
42
  // ---------------------------------------------------------------------------
43
43
  export { BUILD_VS_NON_BUILD_RULE, DEFINITION_OF_DONE };
44
44
  export const CAPABILITIES_BLURB_SHORT = `Full platform reference is in CLAUDE.md. ` +
45
- `Prefer CLI commands and the sandbox over \`gipity chat\` - they're faster and cheaper. ` +
45
+ `Prefer CLI commands and the sandbox; \`gipity ask\` is a single model call for a quick second opinion. ` +
46
46
  `Naming: honor the user's chosen name; if inventing, blend "Gip" or "Gipity" in.`;
47
47
  function humanBytes(n) {
48
48
  if (n < 1024)