flypod 0.1.0
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.
- package/LICENSE +21 -0
- package/README.md +211 -0
- package/dist/bin/deploy.js +322 -0
- package/dist/cli-ezsrcc6t.js +701 -0
- package/dist/src/cli.js +12 -0
- package/package.json +57 -0
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Sergio Serrano
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
ADDED
|
@@ -0,0 +1,211 @@
|
|
|
1
|
+
# flypod
|
|
2
|
+
|
|
3
|
+
Zero-auth, agent-native deploy primitive. Drop a directory of files, get a live URL back. No account, no config, no build pipeline required.
|
|
4
|
+
|
|
5
|
+
```sh
|
|
6
|
+
npx flypod ./dist
|
|
7
|
+
# → https://ab12cd34.flypod.dev
|
|
8
|
+
```
|
|
9
|
+
|
|
10
|
+
## How it works
|
|
11
|
+
|
|
12
|
+
- **No auth to deploy** — POST a zip, receive a URL + one-time tokens
|
|
13
|
+
- **Ephemeral by default** — anonymous deploys expire in 14 days; there are no accounts in v0.1. User accounts and site claiming (to keep a site alive past expiry) are on the roadmap, not yet shipped
|
|
14
|
+
- **Rollback built-in** — every deploy is versioned; roll back with a single call
|
|
15
|
+
- **Render loop** — optional headless screenshot + console capture on every deploy
|
|
16
|
+
|
|
17
|
+
---
|
|
18
|
+
|
|
19
|
+
## CLI
|
|
20
|
+
|
|
21
|
+
```sh
|
|
22
|
+
npx flypod
|
|
23
|
+
# auto-detects dist/, build/, out/, .output/public, .vercel/output/static, public, _site
|
|
24
|
+
# (the first one containing an index.html wins)
|
|
25
|
+
|
|
26
|
+
npx flypod ./somewhere # or give it an explicit path
|
|
27
|
+
```
|
|
28
|
+
|
|
29
|
+
What you see:
|
|
30
|
+
|
|
31
|
+
```
|
|
32
|
+
flypod v0.1.0
|
|
33
|
+
|
|
34
|
+
source dist 12 files · 1.2 MB
|
|
35
|
+
✓ Deployed in 0.8s
|
|
36
|
+
|
|
37
|
+
────────────────────────────────────────────────────────
|
|
38
|
+
● Live
|
|
39
|
+
https://ab12cd34.flypod.dev
|
|
40
|
+
────────────────────────────────────────────────────────
|
|
41
|
+
|
|
42
|
+
manage token <token>
|
|
43
|
+
save it — needed to redeploy or roll back
|
|
44
|
+
|
|
45
|
+
expires in 14 days · ephemeral by default
|
|
46
|
+
```
|
|
47
|
+
|
|
48
|
+
### Agent-friendly modes
|
|
49
|
+
|
|
50
|
+
The CLI detects whether stderr is a TTY. When piped (or under an agent), the
|
|
51
|
+
animations and decorations are stripped automatically. Two flags give you
|
|
52
|
+
stable machine output:
|
|
53
|
+
|
|
54
|
+
```sh
|
|
55
|
+
npx flypod --json
|
|
56
|
+
# {
|
|
57
|
+
# "ok": true,
|
|
58
|
+
# "url": "https://ab12cd34.flypod.dev",
|
|
59
|
+
# "site_id": "ab12cd34",
|
|
60
|
+
# "version_id": "...",
|
|
61
|
+
# "expires_at": 1782929906088,
|
|
62
|
+
# "manage_token": "...",
|
|
63
|
+
# "source": "dist",
|
|
64
|
+
# "files": 12,
|
|
65
|
+
# "bytes": 1234567,
|
|
66
|
+
# "elapsed_ms": 812
|
|
67
|
+
# }
|
|
68
|
+
|
|
69
|
+
npx flypod --quiet
|
|
70
|
+
# stdout: https://ab12cd34.flypod.dev
|
|
71
|
+
# stderr: <manage_token>
|
|
72
|
+
```
|
|
73
|
+
|
|
74
|
+
The URL is always printed alone on stdout in pretty and quiet modes, so
|
|
75
|
+
`URL=$(npx flypod --quiet)` and `npx flypod | tee url.txt` both work.
|
|
76
|
+
|
|
77
|
+
### Flags
|
|
78
|
+
|
|
79
|
+
| Flag | Description |
|
|
80
|
+
|------|-------------|
|
|
81
|
+
| `--json` | Emit a complete JSON result on stdout (replaces pretty output) |
|
|
82
|
+
| `-q, --quiet` | Print only the URL on stdout and the manage token on stderr |
|
|
83
|
+
| `-h, --help` | Show usage |
|
|
84
|
+
| `-v, --version` | Print the version |
|
|
85
|
+
|
|
86
|
+
### Environment
|
|
87
|
+
|
|
88
|
+
| Variable | Description |
|
|
89
|
+
|----------|-------------|
|
|
90
|
+
| `DEPLOY_URL` | Override the deploy server (default: `https://flypod.dev`) |
|
|
91
|
+
| `NO_COLOR` | Disable ANSI colors |
|
|
92
|
+
| `FORCE_COLOR` | Force colors even when stderr is not a TTY |
|
|
93
|
+
|
|
94
|
+
### Install globally to skip `npx`
|
|
95
|
+
|
|
96
|
+
```sh
|
|
97
|
+
npm install -g flypod
|
|
98
|
+
flypod
|
|
99
|
+
```
|
|
100
|
+
|
|
101
|
+
### Exit codes
|
|
102
|
+
|
|
103
|
+
| Code | Meaning |
|
|
104
|
+
|------|---------|
|
|
105
|
+
| `0` | Success |
|
|
106
|
+
| `1` | Runtime error (no build folder, network failure, deploy rejected) |
|
|
107
|
+
| `2` | Usage error (unknown flag) |
|
|
108
|
+
|
|
109
|
+
---
|
|
110
|
+
|
|
111
|
+
## Library
|
|
112
|
+
|
|
113
|
+
```ts
|
|
114
|
+
import { deploySite, collectDist } from "flypod";
|
|
115
|
+
|
|
116
|
+
// collect a local directory
|
|
117
|
+
const files = await collectDist("./dist");
|
|
118
|
+
|
|
119
|
+
// or build the files map yourself
|
|
120
|
+
const files = {
|
|
121
|
+
"index.html": new TextEncoder().encode("<h1>hello</h1>"),
|
|
122
|
+
};
|
|
123
|
+
|
|
124
|
+
const result = await deploySite({ files });
|
|
125
|
+
|
|
126
|
+
console.log(result.url); // https://ab12cd34.flypod.dev
|
|
127
|
+
console.log(result.manage_token); // one-time — save to redeploy / rollback / delete
|
|
128
|
+
```
|
|
129
|
+
|
|
130
|
+
### `deploySite(opts)`
|
|
131
|
+
|
|
132
|
+
| Option | Type | Default | Description |
|
|
133
|
+
|--------|------|---------|-------------|
|
|
134
|
+
| `files` | `Record<string, Uint8Array>` | — | File path → bytes map |
|
|
135
|
+
| `baseUrl` | `string` | `https://flypod.dev` | Override for self-hosted servers |
|
|
136
|
+
| `handle` | `(req) => Promise<Response>` | `fetch` | Injectable transport (used in tests) |
|
|
137
|
+
|
|
138
|
+
Returns a `DeployResult`:
|
|
139
|
+
|
|
140
|
+
```ts
|
|
141
|
+
interface DeployResult {
|
|
142
|
+
site_id: string;
|
|
143
|
+
slug: string;
|
|
144
|
+
url: string; // live URL
|
|
145
|
+
version_id: string;
|
|
146
|
+
expires_at: number; // unix ms; anonymous sites expire 14 days out
|
|
147
|
+
claim_token: string; // reserved for forward-compat; claiming not live in v0.1
|
|
148
|
+
manage_token: string; // one-time; redeploy, rollback, delete
|
|
149
|
+
next_actions: unknown[];
|
|
150
|
+
}
|
|
151
|
+
```
|
|
152
|
+
|
|
153
|
+
### `collectDist(dir)`
|
|
154
|
+
|
|
155
|
+
Reads a local directory into a `Record<string, Uint8Array>` map for `deploySite`.
|
|
156
|
+
|
|
157
|
+
---
|
|
158
|
+
|
|
159
|
+
## Managing a site
|
|
160
|
+
|
|
161
|
+
All management calls use the `manage_token` returned on first deploy.
|
|
162
|
+
|
|
163
|
+
```sh
|
|
164
|
+
# redeploy a new version
|
|
165
|
+
curl -X POST https://flypod.dev/sites/<id>/deploys \
|
|
166
|
+
-H "authorization: Bearer <manage_token>" \
|
|
167
|
+
-H "content-type: application/zip" \
|
|
168
|
+
--data-binary @site.zip
|
|
169
|
+
|
|
170
|
+
# list versions + metadata
|
|
171
|
+
curl https://flypod.dev/sites/<id> \
|
|
172
|
+
-H "authorization: Bearer <manage_token>"
|
|
173
|
+
|
|
174
|
+
# rollback to a previous version
|
|
175
|
+
curl -X POST https://flypod.dev/sites/<id>/rollback \
|
|
176
|
+
-H "authorization: Bearer <manage_token>" \
|
|
177
|
+
-H "content-type: application/json" \
|
|
178
|
+
-d '{"version_id":"<version_id>"}'
|
|
179
|
+
```
|
|
180
|
+
|
|
181
|
+
---
|
|
182
|
+
|
|
183
|
+
## Self-hosting
|
|
184
|
+
|
|
185
|
+
```ts
|
|
186
|
+
import { createApp } from "flypod/server";
|
|
187
|
+
```
|
|
188
|
+
|
|
189
|
+
The server runs on [Cloudflare Workers](https://workers.cloudflare.com) (free tier). Deploy your own instance:
|
|
190
|
+
|
|
191
|
+
```sh
|
|
192
|
+
git clone https://github.com/sdserranog/flypod
|
|
193
|
+
cd flypod
|
|
194
|
+
bunx wrangler deploy
|
|
195
|
+
```
|
|
196
|
+
|
|
197
|
+
Environment variables / secrets:
|
|
198
|
+
|
|
199
|
+
| Variable | Default | Description |
|
|
200
|
+
|----------|---------|-------------|
|
|
201
|
+
| `BASE_HOST` | `flypod.dev` | Wildcard subdomain root |
|
|
202
|
+
| `PUBLIC_SCHEME` | `https` | `http` or `https` |
|
|
203
|
+
| `LIBSQL_URL` | — | Turso/libSQL connection URL |
|
|
204
|
+
| `LIBSQL_AUTH_TOKEN` | — | Turso auth token |
|
|
205
|
+
| `SAFE_BROWSING_KEY` | — | Enables Google Safe Browsing link scan |
|
|
206
|
+
|
|
207
|
+
---
|
|
208
|
+
|
|
209
|
+
## License
|
|
210
|
+
|
|
211
|
+
MIT
|
|
@@ -0,0 +1,322 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
import {
|
|
3
|
+
collectDist,
|
|
4
|
+
deploySite,
|
|
5
|
+
resolveDeployDir
|
|
6
|
+
} from "../cli-ezsrcc6t.js";
|
|
7
|
+
|
|
8
|
+
// bin/deploy.ts
|
|
9
|
+
import { readFile } from "node:fs/promises";
|
|
10
|
+
import { relative } from "node:path";
|
|
11
|
+
import { fileURLToPath } from "node:url";
|
|
12
|
+
|
|
13
|
+
// src/ui.ts
|
|
14
|
+
var ESC = "\x1B[";
|
|
15
|
+
function envBool(name) {
|
|
16
|
+
const v = process.env[name];
|
|
17
|
+
return v !== undefined && v !== "" && v !== "0" && v !== "false";
|
|
18
|
+
}
|
|
19
|
+
function colorsEnabled(stream = process.stderr) {
|
|
20
|
+
if (envBool("NO_COLOR"))
|
|
21
|
+
return false;
|
|
22
|
+
if (envBool("FORCE_COLOR"))
|
|
23
|
+
return true;
|
|
24
|
+
return Boolean(stream.isTTY);
|
|
25
|
+
}
|
|
26
|
+
var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
|
|
27
|
+
function paint(open, s) {
|
|
28
|
+
return `${ESC}${open}m${s}${ESC}0m`;
|
|
29
|
+
}
|
|
30
|
+
function makeStyle(enabled) {
|
|
31
|
+
if (!enabled) {
|
|
32
|
+
const id = (s) => s;
|
|
33
|
+
return { dim: id, bold: id, accent: id, ok: id, err: id, muted: id };
|
|
34
|
+
}
|
|
35
|
+
return {
|
|
36
|
+
dim: (s) => paint("2", s),
|
|
37
|
+
bold: (s) => paint("1", s),
|
|
38
|
+
accent: (s) => paint("38;5;191", s),
|
|
39
|
+
ok: (s) => paint("38;5;120", s),
|
|
40
|
+
err: (s) => paint("38;5;203", s),
|
|
41
|
+
muted: (s) => paint("38;5;245", s)
|
|
42
|
+
};
|
|
43
|
+
}
|
|
44
|
+
function makeSpinner(stream = process.stderr, style = makeStyle(false)) {
|
|
45
|
+
const tty = Boolean(stream.isTTY);
|
|
46
|
+
let timer;
|
|
47
|
+
let frame = 0;
|
|
48
|
+
let label = "";
|
|
49
|
+
let started = false;
|
|
50
|
+
const writeFrame = () => {
|
|
51
|
+
stream.write(`\r${ESC}2K ${style.accent(FRAMES[frame] ?? "·")} ${label}`);
|
|
52
|
+
};
|
|
53
|
+
const clearLine = () => {
|
|
54
|
+
if (tty)
|
|
55
|
+
stream.write(`\r${ESC}2K`);
|
|
56
|
+
};
|
|
57
|
+
return {
|
|
58
|
+
start(text) {
|
|
59
|
+
label = text;
|
|
60
|
+
started = true;
|
|
61
|
+
if (tty) {
|
|
62
|
+
writeFrame();
|
|
63
|
+
timer = setInterval(() => {
|
|
64
|
+
frame = (frame + 1) % FRAMES.length;
|
|
65
|
+
writeFrame();
|
|
66
|
+
}, 80);
|
|
67
|
+
} else {
|
|
68
|
+
stream.write(` ${style.dim("·")} ${label}
|
|
69
|
+
`);
|
|
70
|
+
}
|
|
71
|
+
},
|
|
72
|
+
update(text) {
|
|
73
|
+
label = text;
|
|
74
|
+
if (!started)
|
|
75
|
+
return;
|
|
76
|
+
if (tty)
|
|
77
|
+
writeFrame();
|
|
78
|
+
else
|
|
79
|
+
stream.write(` ${style.dim("·")} ${label}
|
|
80
|
+
`);
|
|
81
|
+
},
|
|
82
|
+
success(text) {
|
|
83
|
+
clearLine();
|
|
84
|
+
stream.write(` ${style.ok("✓")} ${text}
|
|
85
|
+
`);
|
|
86
|
+
this.stop();
|
|
87
|
+
},
|
|
88
|
+
fail(text) {
|
|
89
|
+
clearLine();
|
|
90
|
+
stream.write(` ${style.err("✗")} ${text}
|
|
91
|
+
`);
|
|
92
|
+
this.stop();
|
|
93
|
+
},
|
|
94
|
+
stop() {
|
|
95
|
+
if (timer)
|
|
96
|
+
clearInterval(timer);
|
|
97
|
+
timer = undefined;
|
|
98
|
+
started = false;
|
|
99
|
+
}
|
|
100
|
+
};
|
|
101
|
+
}
|
|
102
|
+
function fmtBytes(n) {
|
|
103
|
+
if (n < 1024)
|
|
104
|
+
return `${n} B`;
|
|
105
|
+
if (n < 1024 * 1024)
|
|
106
|
+
return `${(n / 1024).toFixed(n < 10 * 1024 ? 1 : 0)} KB`;
|
|
107
|
+
return `${(n / (1024 * 1024)).toFixed(n < 10 * 1024 * 1024 ? 2 : 1)} MB`;
|
|
108
|
+
}
|
|
109
|
+
function fmtSeconds(ms) {
|
|
110
|
+
return `${(ms / 1000).toFixed(1)}s`;
|
|
111
|
+
}
|
|
112
|
+
function fmtCount(n, singular) {
|
|
113
|
+
return `${n} ${singular}${n === 1 ? "" : "s"}`;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
// bin/deploy.ts
|
|
117
|
+
function parseArgs(argv) {
|
|
118
|
+
const out = { json: false, quiet: false, help: false, version: false };
|
|
119
|
+
for (const a of argv) {
|
|
120
|
+
if (a === "--json")
|
|
121
|
+
out.json = true;
|
|
122
|
+
else if (a === "-q" || a === "--quiet")
|
|
123
|
+
out.quiet = true;
|
|
124
|
+
else if (a === "-h" || a === "--help")
|
|
125
|
+
out.help = true;
|
|
126
|
+
else if (a === "-v" || a === "--version")
|
|
127
|
+
out.version = true;
|
|
128
|
+
else if (a.startsWith("-")) {
|
|
129
|
+
process.stderr.write(`flypod: unknown flag "${a}"
|
|
130
|
+
Run \`flypod --help\` for usage.
|
|
131
|
+
`);
|
|
132
|
+
process.exit(2);
|
|
133
|
+
} else if (!out.path)
|
|
134
|
+
out.path = a;
|
|
135
|
+
}
|
|
136
|
+
return out;
|
|
137
|
+
}
|
|
138
|
+
async function readVersion() {
|
|
139
|
+
const here = fileURLToPath(import.meta.url);
|
|
140
|
+
for (const rel of ["../../package.json", "../package.json"]) {
|
|
141
|
+
try {
|
|
142
|
+
const url = new URL(rel, `file://${here}`);
|
|
143
|
+
const text = await readFile(url, "utf8");
|
|
144
|
+
const version = JSON.parse(text).version;
|
|
145
|
+
if (version)
|
|
146
|
+
return version;
|
|
147
|
+
} catch {}
|
|
148
|
+
}
|
|
149
|
+
return "0.0.0";
|
|
150
|
+
}
|
|
151
|
+
function showHelp(version) {
|
|
152
|
+
const usage = `flypod v${version}
|
|
153
|
+
Drop files, get a live URL.
|
|
154
|
+
|
|
155
|
+
Usage:
|
|
156
|
+
flypod [path] Deploy a folder (default: auto-detected)
|
|
157
|
+
flypod [path] --json Emit a JSON result instead of pretty output
|
|
158
|
+
flypod [path] -q, --quiet Print only the URL
|
|
159
|
+
flypod -h, --help Show this help
|
|
160
|
+
flypod -v, --version Show the flypod version
|
|
161
|
+
|
|
162
|
+
Environment:
|
|
163
|
+
DEPLOY_URL Override the deploy server (default: https://flypod.dev)
|
|
164
|
+
NO_COLOR Disable ANSI colors
|
|
165
|
+
FORCE_COLOR Force ANSI colors even when stderr is not a TTY
|
|
166
|
+
|
|
167
|
+
When no path is given, flypod looks for a build folder in the current directory:
|
|
168
|
+
dist, build, out, .output/public, .vercel/output/static, public, _site
|
|
169
|
+
(each must contain an index.html)
|
|
170
|
+
|
|
171
|
+
Docs: https://flypod.dev
|
|
172
|
+
Source: https://github.com/sdserranog/flypod
|
|
173
|
+
`;
|
|
174
|
+
process.stdout.write(usage);
|
|
175
|
+
}
|
|
176
|
+
function shortDir(dir) {
|
|
177
|
+
const rel = relative(process.cwd(), dir);
|
|
178
|
+
return rel === "" || rel.startsWith("..") ? dir : rel || ".";
|
|
179
|
+
}
|
|
180
|
+
async function main() {
|
|
181
|
+
const args = parseArgs(process.argv.slice(2));
|
|
182
|
+
const version = await readVersion();
|
|
183
|
+
if (args.help) {
|
|
184
|
+
showHelp(version);
|
|
185
|
+
return;
|
|
186
|
+
}
|
|
187
|
+
if (args.version) {
|
|
188
|
+
process.stdout.write(`${version}
|
|
189
|
+
`);
|
|
190
|
+
return;
|
|
191
|
+
}
|
|
192
|
+
const baseUrl = process.env.DEPLOY_URL ?? "https://flypod.dev";
|
|
193
|
+
const useUI = !args.json && !args.quiet;
|
|
194
|
+
const style = makeStyle(colorsEnabled(process.stderr) && useUI);
|
|
195
|
+
if (useUI) {
|
|
196
|
+
process.stderr.write(`
|
|
197
|
+
${style.bold(style.accent("flypod"))} ${style.dim(`v${version}`)}
|
|
198
|
+
|
|
199
|
+
`);
|
|
200
|
+
}
|
|
201
|
+
let dir;
|
|
202
|
+
try {
|
|
203
|
+
dir = await resolveDeployDir({ explicit: args.path });
|
|
204
|
+
} catch (error) {
|
|
205
|
+
const msg = error.message;
|
|
206
|
+
if (args.json) {
|
|
207
|
+
process.stdout.write(`${JSON.stringify({ ok: false, error: msg })}
|
|
208
|
+
`);
|
|
209
|
+
} else {
|
|
210
|
+
process.stderr.write(` ${style.err("✗")} ${msg}
|
|
211
|
+
|
|
212
|
+
`);
|
|
213
|
+
}
|
|
214
|
+
process.exit(1);
|
|
215
|
+
}
|
|
216
|
+
let files;
|
|
217
|
+
try {
|
|
218
|
+
files = await collectDist(dir);
|
|
219
|
+
} catch (error) {
|
|
220
|
+
const msg = `Could not read ${shortDir(dir)}: ${error.message}`;
|
|
221
|
+
if (args.json) {
|
|
222
|
+
process.stdout.write(`${JSON.stringify({ ok: false, error: msg })}
|
|
223
|
+
`);
|
|
224
|
+
} else {
|
|
225
|
+
process.stderr.write(` ${style.err("✗")} ${msg}
|
|
226
|
+
|
|
227
|
+
`);
|
|
228
|
+
}
|
|
229
|
+
process.exit(1);
|
|
230
|
+
}
|
|
231
|
+
const fileNames = Object.keys(files);
|
|
232
|
+
const totalBytes = fileNames.reduce((sum, name) => sum + (files[name]?.byteLength ?? 0), 0);
|
|
233
|
+
if (fileNames.length === 0) {
|
|
234
|
+
const msg = `No files found in ${shortDir(dir)}.`;
|
|
235
|
+
if (args.json) {
|
|
236
|
+
process.stdout.write(`${JSON.stringify({ ok: false, error: msg })}
|
|
237
|
+
`);
|
|
238
|
+
} else {
|
|
239
|
+
process.stderr.write(` ${style.err("✗")} ${msg}
|
|
240
|
+
|
|
241
|
+
`);
|
|
242
|
+
}
|
|
243
|
+
process.exit(1);
|
|
244
|
+
}
|
|
245
|
+
if (useUI) {
|
|
246
|
+
process.stderr.write(` ${style.muted("source")} ${style.bold(shortDir(dir))} ${style.dim(`${fmtCount(fileNames.length, "file")} · ${fmtBytes(totalBytes)}`)}
|
|
247
|
+
`);
|
|
248
|
+
}
|
|
249
|
+
const spinner = useUI ? makeSpinner(process.stderr, style) : { start: () => {}, update: () => {}, success: () => {}, fail: () => {}, stop: () => {} };
|
|
250
|
+
spinner.start(`Uploading ${fmtBytes(totalBytes)}`);
|
|
251
|
+
const started = Date.now();
|
|
252
|
+
let result;
|
|
253
|
+
try {
|
|
254
|
+
result = await deploySite({ baseUrl, files });
|
|
255
|
+
} catch (error) {
|
|
256
|
+
spinner.fail("Deploy failed.");
|
|
257
|
+
const msg = error.message;
|
|
258
|
+
if (args.json) {
|
|
259
|
+
process.stdout.write(`${JSON.stringify({ ok: false, error: msg })}
|
|
260
|
+
`);
|
|
261
|
+
} else {
|
|
262
|
+
process.stderr.write(` ${style.dim(msg)}
|
|
263
|
+
|
|
264
|
+
`);
|
|
265
|
+
}
|
|
266
|
+
process.exit(1);
|
|
267
|
+
}
|
|
268
|
+
const elapsed = Date.now() - started;
|
|
269
|
+
spinner.success(`Deployed in ${fmtSeconds(elapsed)}`);
|
|
270
|
+
if (args.json) {
|
|
271
|
+
process.stdout.write(`${JSON.stringify({
|
|
272
|
+
ok: true,
|
|
273
|
+
url: result.url,
|
|
274
|
+
site_id: result.site_id,
|
|
275
|
+
version_id: result.version_id,
|
|
276
|
+
expires_at: result.expires_at,
|
|
277
|
+
manage_token: result.manage_token,
|
|
278
|
+
source: shortDir(dir),
|
|
279
|
+
files: fileNames.length,
|
|
280
|
+
bytes: totalBytes,
|
|
281
|
+
elapsed_ms: elapsed
|
|
282
|
+
}, null, 2)}
|
|
283
|
+
`);
|
|
284
|
+
return;
|
|
285
|
+
}
|
|
286
|
+
if (args.quiet) {
|
|
287
|
+
process.stdout.write(`${result.url}
|
|
288
|
+
`);
|
|
289
|
+
process.stderr.write(`${result.manage_token}
|
|
290
|
+
`);
|
|
291
|
+
return;
|
|
292
|
+
}
|
|
293
|
+
const rule = style.dim("─".repeat(56));
|
|
294
|
+
process.stderr.write(`
|
|
295
|
+
${rule}
|
|
296
|
+
`);
|
|
297
|
+
process.stderr.write(` ${style.ok("●")} ${style.bold("Live")}
|
|
298
|
+
`);
|
|
299
|
+
process.stderr.write(` ${style.accent(result.url)}
|
|
300
|
+
`);
|
|
301
|
+
process.stderr.write(` ${rule}
|
|
302
|
+
|
|
303
|
+
`);
|
|
304
|
+
process.stderr.write(` ${style.muted("manage token")} ${style.bold(result.manage_token)}
|
|
305
|
+
` + ` ${style.muted(" ")} ${style.dim("save it — needed to redeploy or roll back")}
|
|
306
|
+
|
|
307
|
+
`);
|
|
308
|
+
const expiry = typeof result.expires_at === "number" ? `in ${Math.max(0, Math.round((result.expires_at - Date.now()) / 86400000))} days · ephemeral by default` : "never (claimed)";
|
|
309
|
+
process.stderr.write(` ${style.muted("expires ")} ${style.dim(expiry)}
|
|
310
|
+
|
|
311
|
+
`);
|
|
312
|
+
process.stdout.write(`${result.url}
|
|
313
|
+
`);
|
|
314
|
+
}
|
|
315
|
+
main().catch((error) => {
|
|
316
|
+
process.stderr.write(`
|
|
317
|
+
flypod: unexpected error
|
|
318
|
+
${error.message}
|
|
319
|
+
|
|
320
|
+
`);
|
|
321
|
+
process.exit(1);
|
|
322
|
+
});
|
|
@@ -0,0 +1,701 @@
|
|
|
1
|
+
// src/cli.ts
|
|
2
|
+
import { readdir, readFile, stat } from "node:fs/promises";
|
|
3
|
+
import { join, relative } from "node:path";
|
|
4
|
+
|
|
5
|
+
// ../../node_modules/.bun/fflate@0.8.3/node_modules/fflate/esm/index.mjs
|
|
6
|
+
import { createRequire } from "module";
|
|
7
|
+
var require2 = createRequire("/");
|
|
8
|
+
var _a;
|
|
9
|
+
var Worker;
|
|
10
|
+
var isMarkedAsUntransferable;
|
|
11
|
+
try {
|
|
12
|
+
_a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
|
|
13
|
+
} catch (e) {}
|
|
14
|
+
var u8 = Uint8Array;
|
|
15
|
+
var u16 = Uint16Array;
|
|
16
|
+
var i32 = Int32Array;
|
|
17
|
+
var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
|
|
18
|
+
var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
|
|
19
|
+
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
|
|
20
|
+
var freb = function(eb, start) {
|
|
21
|
+
var b = new u16(31);
|
|
22
|
+
for (var i = 0;i < 31; ++i) {
|
|
23
|
+
b[i] = start += 1 << eb[i - 1];
|
|
24
|
+
}
|
|
25
|
+
var r = new i32(b[30]);
|
|
26
|
+
for (var i = 1;i < 30; ++i) {
|
|
27
|
+
for (var j = b[i];j < b[i + 1]; ++j) {
|
|
28
|
+
r[j] = j - b[i] << 5 | i;
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
return { b, r };
|
|
32
|
+
};
|
|
33
|
+
var _a = freb(fleb, 2);
|
|
34
|
+
var fl = _a.b;
|
|
35
|
+
var revfl = _a.r;
|
|
36
|
+
fl[28] = 258, revfl[258] = 28;
|
|
37
|
+
var _b = freb(fdeb, 0);
|
|
38
|
+
var fd = _b.b;
|
|
39
|
+
var revfd = _b.r;
|
|
40
|
+
var rev = new u16(32768);
|
|
41
|
+
for (i = 0;i < 32768; ++i) {
|
|
42
|
+
x = (i & 43690) >> 1 | (i & 21845) << 1;
|
|
43
|
+
x = (x & 52428) >> 2 | (x & 13107) << 2;
|
|
44
|
+
x = (x & 61680) >> 4 | (x & 3855) << 4;
|
|
45
|
+
rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
|
|
46
|
+
}
|
|
47
|
+
var x;
|
|
48
|
+
var i;
|
|
49
|
+
var hMap = function(cd, mb, r) {
|
|
50
|
+
var s = cd.length;
|
|
51
|
+
var i2 = 0;
|
|
52
|
+
var l = new u16(mb);
|
|
53
|
+
for (;i2 < s; ++i2) {
|
|
54
|
+
if (cd[i2])
|
|
55
|
+
++l[cd[i2] - 1];
|
|
56
|
+
}
|
|
57
|
+
var le = new u16(mb);
|
|
58
|
+
for (i2 = 1;i2 < mb; ++i2) {
|
|
59
|
+
le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
|
|
60
|
+
}
|
|
61
|
+
var co;
|
|
62
|
+
if (r) {
|
|
63
|
+
co = new u16(1 << mb);
|
|
64
|
+
var rvb = 15 - mb;
|
|
65
|
+
for (i2 = 0;i2 < s; ++i2) {
|
|
66
|
+
if (cd[i2]) {
|
|
67
|
+
var sv = i2 << 4 | cd[i2];
|
|
68
|
+
var r_1 = mb - cd[i2];
|
|
69
|
+
var v = le[cd[i2] - 1]++ << r_1;
|
|
70
|
+
for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
|
|
71
|
+
co[rev[v] >> rvb] = sv;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
} else {
|
|
76
|
+
co = new u16(s);
|
|
77
|
+
for (i2 = 0;i2 < s; ++i2) {
|
|
78
|
+
if (cd[i2]) {
|
|
79
|
+
co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
return co;
|
|
84
|
+
};
|
|
85
|
+
var flt = new u8(288);
|
|
86
|
+
for (i = 0;i < 144; ++i)
|
|
87
|
+
flt[i] = 8;
|
|
88
|
+
var i;
|
|
89
|
+
for (i = 144;i < 256; ++i)
|
|
90
|
+
flt[i] = 9;
|
|
91
|
+
var i;
|
|
92
|
+
for (i = 256;i < 280; ++i)
|
|
93
|
+
flt[i] = 7;
|
|
94
|
+
var i;
|
|
95
|
+
for (i = 280;i < 288; ++i)
|
|
96
|
+
flt[i] = 8;
|
|
97
|
+
var i;
|
|
98
|
+
var fdt = new u8(32);
|
|
99
|
+
for (i = 0;i < 32; ++i)
|
|
100
|
+
fdt[i] = 5;
|
|
101
|
+
var i;
|
|
102
|
+
var flm = /* @__PURE__ */ hMap(flt, 9, 0);
|
|
103
|
+
var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
|
|
104
|
+
var shft = function(p) {
|
|
105
|
+
return (p + 7) / 8 | 0;
|
|
106
|
+
};
|
|
107
|
+
var slc = function(v, s, e) {
|
|
108
|
+
if (s == null || s < 0)
|
|
109
|
+
s = 0;
|
|
110
|
+
if (e == null || e > v.length)
|
|
111
|
+
e = v.length;
|
|
112
|
+
return new u8(v.subarray(s, e));
|
|
113
|
+
};
|
|
114
|
+
var ec = [
|
|
115
|
+
"unexpected EOF",
|
|
116
|
+
"invalid block type",
|
|
117
|
+
"invalid length/literal",
|
|
118
|
+
"invalid distance",
|
|
119
|
+
"stream finished",
|
|
120
|
+
"no stream handler",
|
|
121
|
+
,
|
|
122
|
+
"no callback",
|
|
123
|
+
"invalid UTF-8 data",
|
|
124
|
+
"extra field too long",
|
|
125
|
+
"date not in range 1980-2099",
|
|
126
|
+
"filename too long",
|
|
127
|
+
"stream finishing",
|
|
128
|
+
"invalid zip data"
|
|
129
|
+
];
|
|
130
|
+
var err = function(ind, msg, nt) {
|
|
131
|
+
var e = new Error(msg || ec[ind]);
|
|
132
|
+
e.code = ind;
|
|
133
|
+
if (Error.captureStackTrace)
|
|
134
|
+
Error.captureStackTrace(e, err);
|
|
135
|
+
if (!nt)
|
|
136
|
+
throw e;
|
|
137
|
+
return e;
|
|
138
|
+
};
|
|
139
|
+
var wbits = function(d, p, v) {
|
|
140
|
+
v <<= p & 7;
|
|
141
|
+
var o = p / 8 | 0;
|
|
142
|
+
d[o] |= v;
|
|
143
|
+
d[o + 1] |= v >> 8;
|
|
144
|
+
};
|
|
145
|
+
var wbits16 = function(d, p, v) {
|
|
146
|
+
v <<= p & 7;
|
|
147
|
+
var o = p / 8 | 0;
|
|
148
|
+
d[o] |= v;
|
|
149
|
+
d[o + 1] |= v >> 8;
|
|
150
|
+
d[o + 2] |= v >> 16;
|
|
151
|
+
};
|
|
152
|
+
var hTree = function(d, mb) {
|
|
153
|
+
var t = [];
|
|
154
|
+
for (var i2 = 0;i2 < d.length; ++i2) {
|
|
155
|
+
if (d[i2])
|
|
156
|
+
t.push({ s: i2, f: d[i2] });
|
|
157
|
+
}
|
|
158
|
+
var s = t.length;
|
|
159
|
+
var t2 = t.slice();
|
|
160
|
+
if (!s)
|
|
161
|
+
return { t: et, l: 0 };
|
|
162
|
+
if (s == 1) {
|
|
163
|
+
var v = new u8(t[0].s + 1);
|
|
164
|
+
v[t[0].s] = 1;
|
|
165
|
+
return { t: v, l: 1 };
|
|
166
|
+
}
|
|
167
|
+
t.sort(function(a, b) {
|
|
168
|
+
return a.f - b.f;
|
|
169
|
+
});
|
|
170
|
+
t.push({ s: -1, f: 25001 });
|
|
171
|
+
var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
|
|
172
|
+
t[0] = { s: -1, f: l.f + r.f, l, r };
|
|
173
|
+
while (i1 != s - 1) {
|
|
174
|
+
l = t[t[i0].f < t[i22].f ? i0++ : i22++];
|
|
175
|
+
r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
|
|
176
|
+
t[i1++] = { s: -1, f: l.f + r.f, l, r };
|
|
177
|
+
}
|
|
178
|
+
var maxSym = t2[0].s;
|
|
179
|
+
for (var i2 = 1;i2 < s; ++i2) {
|
|
180
|
+
if (t2[i2].s > maxSym)
|
|
181
|
+
maxSym = t2[i2].s;
|
|
182
|
+
}
|
|
183
|
+
var tr = new u16(maxSym + 1);
|
|
184
|
+
var mbt = ln(t[i1 - 1], tr, 0);
|
|
185
|
+
if (mbt > mb) {
|
|
186
|
+
var i2 = 0, dt = 0;
|
|
187
|
+
var lft = mbt - mb, cst = 1 << lft;
|
|
188
|
+
t2.sort(function(a, b) {
|
|
189
|
+
return tr[b.s] - tr[a.s] || a.f - b.f;
|
|
190
|
+
});
|
|
191
|
+
for (;i2 < s; ++i2) {
|
|
192
|
+
var i2_1 = t2[i2].s;
|
|
193
|
+
if (tr[i2_1] > mb) {
|
|
194
|
+
dt += cst - (1 << mbt - tr[i2_1]);
|
|
195
|
+
tr[i2_1] = mb;
|
|
196
|
+
} else
|
|
197
|
+
break;
|
|
198
|
+
}
|
|
199
|
+
dt >>= lft;
|
|
200
|
+
while (dt > 0) {
|
|
201
|
+
var i2_2 = t2[i2].s;
|
|
202
|
+
if (tr[i2_2] < mb)
|
|
203
|
+
dt -= 1 << mb - tr[i2_2]++ - 1;
|
|
204
|
+
else
|
|
205
|
+
++i2;
|
|
206
|
+
}
|
|
207
|
+
for (;i2 >= 0 && dt; --i2) {
|
|
208
|
+
var i2_3 = t2[i2].s;
|
|
209
|
+
if (tr[i2_3] == mb) {
|
|
210
|
+
--tr[i2_3];
|
|
211
|
+
++dt;
|
|
212
|
+
}
|
|
213
|
+
}
|
|
214
|
+
mbt = mb;
|
|
215
|
+
}
|
|
216
|
+
return { t: new u8(tr), l: mbt };
|
|
217
|
+
};
|
|
218
|
+
var ln = function(n, l, d) {
|
|
219
|
+
return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
|
|
220
|
+
};
|
|
221
|
+
var lc = function(c) {
|
|
222
|
+
var s = c.length;
|
|
223
|
+
while (s && !c[--s])
|
|
224
|
+
;
|
|
225
|
+
var cl = new u16(++s);
|
|
226
|
+
var cli = 0, cln = c[0], cls = 1;
|
|
227
|
+
var w = function(v) {
|
|
228
|
+
cl[cli++] = v;
|
|
229
|
+
};
|
|
230
|
+
for (var i2 = 1;i2 <= s; ++i2) {
|
|
231
|
+
if (c[i2] == cln && i2 != s)
|
|
232
|
+
++cls;
|
|
233
|
+
else {
|
|
234
|
+
if (!cln && cls > 2) {
|
|
235
|
+
for (;cls > 138; cls -= 138)
|
|
236
|
+
w(32754);
|
|
237
|
+
if (cls > 2) {
|
|
238
|
+
w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
|
|
239
|
+
cls = 0;
|
|
240
|
+
}
|
|
241
|
+
} else if (cls > 3) {
|
|
242
|
+
w(cln), --cls;
|
|
243
|
+
for (;cls > 6; cls -= 6)
|
|
244
|
+
w(8304);
|
|
245
|
+
if (cls > 2)
|
|
246
|
+
w(cls - 3 << 5 | 8208), cls = 0;
|
|
247
|
+
}
|
|
248
|
+
while (cls--)
|
|
249
|
+
w(cln);
|
|
250
|
+
cls = 1;
|
|
251
|
+
cln = c[i2];
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
return { c: cl.subarray(0, cli), n: s };
|
|
255
|
+
};
|
|
256
|
+
var clen = function(cf, cl) {
|
|
257
|
+
var l = 0;
|
|
258
|
+
for (var i2 = 0;i2 < cl.length; ++i2)
|
|
259
|
+
l += cf[i2] * cl[i2];
|
|
260
|
+
return l;
|
|
261
|
+
};
|
|
262
|
+
var wfblk = function(out, pos, dat) {
|
|
263
|
+
var s = dat.length;
|
|
264
|
+
var o = shft(pos + 2);
|
|
265
|
+
out[o] = s & 255;
|
|
266
|
+
out[o + 1] = s >> 8;
|
|
267
|
+
out[o + 2] = out[o] ^ 255;
|
|
268
|
+
out[o + 3] = out[o + 1] ^ 255;
|
|
269
|
+
for (var i2 = 0;i2 < s; ++i2)
|
|
270
|
+
out[o + i2 + 4] = dat[i2];
|
|
271
|
+
return (o + 4 + s) * 8;
|
|
272
|
+
};
|
|
273
|
+
var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
|
|
274
|
+
wbits(out, p++, final);
|
|
275
|
+
++lf[256];
|
|
276
|
+
var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
|
|
277
|
+
var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
|
|
278
|
+
var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
|
|
279
|
+
var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
|
|
280
|
+
var lcfreq = new u16(19);
|
|
281
|
+
for (var i2 = 0;i2 < lclt.length; ++i2)
|
|
282
|
+
++lcfreq[lclt[i2] & 31];
|
|
283
|
+
for (var i2 = 0;i2 < lcdt.length; ++i2)
|
|
284
|
+
++lcfreq[lcdt[i2] & 31];
|
|
285
|
+
var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
|
|
286
|
+
var nlcc = 19;
|
|
287
|
+
for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
|
|
288
|
+
;
|
|
289
|
+
var flen = bl + 5 << 3;
|
|
290
|
+
var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
|
|
291
|
+
var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
|
|
292
|
+
if (bs >= 0 && flen <= ftlen && flen <= dtlen)
|
|
293
|
+
return wfblk(out, p, dat.subarray(bs, bs + bl));
|
|
294
|
+
var lm, ll, dm, dl;
|
|
295
|
+
wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
|
|
296
|
+
if (dtlen < ftlen) {
|
|
297
|
+
lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
|
|
298
|
+
var llm = hMap(lct, mlcb, 0);
|
|
299
|
+
wbits(out, p, nlc - 257);
|
|
300
|
+
wbits(out, p + 5, ndc - 1);
|
|
301
|
+
wbits(out, p + 10, nlcc - 4);
|
|
302
|
+
p += 14;
|
|
303
|
+
for (var i2 = 0;i2 < nlcc; ++i2)
|
|
304
|
+
wbits(out, p + 3 * i2, lct[clim[i2]]);
|
|
305
|
+
p += 3 * nlcc;
|
|
306
|
+
var lcts = [lclt, lcdt];
|
|
307
|
+
for (var it = 0;it < 2; ++it) {
|
|
308
|
+
var clct = lcts[it];
|
|
309
|
+
for (var i2 = 0;i2 < clct.length; ++i2) {
|
|
310
|
+
var len = clct[i2] & 31;
|
|
311
|
+
wbits(out, p, llm[len]), p += lct[len];
|
|
312
|
+
if (len > 15)
|
|
313
|
+
wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
} else {
|
|
317
|
+
lm = flm, ll = flt, dm = fdm, dl = fdt;
|
|
318
|
+
}
|
|
319
|
+
for (var i2 = 0;i2 < li; ++i2) {
|
|
320
|
+
var sym = syms[i2];
|
|
321
|
+
if (sym > 255) {
|
|
322
|
+
var len = sym >> 18 & 31;
|
|
323
|
+
wbits16(out, p, lm[len + 257]), p += ll[len + 257];
|
|
324
|
+
if (len > 7)
|
|
325
|
+
wbits(out, p, sym >> 23 & 31), p += fleb[len];
|
|
326
|
+
var dst = sym & 31;
|
|
327
|
+
wbits16(out, p, dm[dst]), p += dl[dst];
|
|
328
|
+
if (dst > 3)
|
|
329
|
+
wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
|
|
330
|
+
} else {
|
|
331
|
+
wbits16(out, p, lm[sym]), p += ll[sym];
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
wbits16(out, p, lm[256]);
|
|
335
|
+
return p + ll[256];
|
|
336
|
+
};
|
|
337
|
+
var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
|
|
338
|
+
var et = /* @__PURE__ */ new u8(0);
|
|
339
|
+
var dflt = function(dat, lvl, plvl, pre, post, st) {
|
|
340
|
+
var s = st.z || dat.length;
|
|
341
|
+
var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
|
|
342
|
+
var w = o.subarray(pre, o.length - post);
|
|
343
|
+
var lst = st.l;
|
|
344
|
+
var pos = (st.r || 0) & 7;
|
|
345
|
+
if (lvl) {
|
|
346
|
+
if (pos)
|
|
347
|
+
w[0] = st.r >> 3;
|
|
348
|
+
var opt = deo[lvl - 1];
|
|
349
|
+
var n = opt >> 13, c = opt & 8191;
|
|
350
|
+
var msk_1 = (1 << plvl) - 1;
|
|
351
|
+
var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
|
|
352
|
+
var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
|
|
353
|
+
var hsh = function(i3) {
|
|
354
|
+
return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
|
|
355
|
+
};
|
|
356
|
+
var syms = new i32(25000);
|
|
357
|
+
var lf = new u16(288), df = new u16(32);
|
|
358
|
+
var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
|
|
359
|
+
for (;i2 + 2 < s; ++i2) {
|
|
360
|
+
var hv = hsh(i2);
|
|
361
|
+
var imod = i2 & 32767, pimod = head[hv];
|
|
362
|
+
prev[imod] = pimod;
|
|
363
|
+
head[hv] = imod;
|
|
364
|
+
if (wi <= i2) {
|
|
365
|
+
var rem = s - i2;
|
|
366
|
+
if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
|
|
367
|
+
pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
|
|
368
|
+
li = lc_1 = eb = 0, bs = i2;
|
|
369
|
+
for (var j = 0;j < 286; ++j)
|
|
370
|
+
lf[j] = 0;
|
|
371
|
+
for (var j = 0;j < 30; ++j)
|
|
372
|
+
df[j] = 0;
|
|
373
|
+
}
|
|
374
|
+
var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
|
|
375
|
+
if (rem > 2 && hv == hsh(i2 - dif)) {
|
|
376
|
+
var maxn = Math.min(n, rem) - 1;
|
|
377
|
+
var maxd = Math.min(32767, i2);
|
|
378
|
+
var ml = Math.min(258, rem);
|
|
379
|
+
while (dif <= maxd && --ch_1 && imod != pimod) {
|
|
380
|
+
if (dat[i2 + l] == dat[i2 + l - dif]) {
|
|
381
|
+
var nl = 0;
|
|
382
|
+
for (;nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
|
|
383
|
+
;
|
|
384
|
+
if (nl > l) {
|
|
385
|
+
l = nl, d = dif;
|
|
386
|
+
if (nl > maxn)
|
|
387
|
+
break;
|
|
388
|
+
var mmd = Math.min(dif, nl - 2);
|
|
389
|
+
var md = 0;
|
|
390
|
+
for (var j = 0;j < mmd; ++j) {
|
|
391
|
+
var ti = i2 - dif + j & 32767;
|
|
392
|
+
var pti = prev[ti];
|
|
393
|
+
var cd = ti - pti & 32767;
|
|
394
|
+
if (cd > md)
|
|
395
|
+
md = cd, pimod = ti;
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
}
|
|
399
|
+
imod = pimod, pimod = prev[imod];
|
|
400
|
+
dif += imod - pimod & 32767;
|
|
401
|
+
}
|
|
402
|
+
}
|
|
403
|
+
if (d) {
|
|
404
|
+
syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
|
|
405
|
+
var lin = revfl[l] & 31, din = revfd[d] & 31;
|
|
406
|
+
eb += fleb[lin] + fdeb[din];
|
|
407
|
+
++lf[257 + lin];
|
|
408
|
+
++df[din];
|
|
409
|
+
wi = i2 + l;
|
|
410
|
+
++lc_1;
|
|
411
|
+
} else {
|
|
412
|
+
syms[li++] = dat[i2];
|
|
413
|
+
++lf[dat[i2]];
|
|
414
|
+
}
|
|
415
|
+
}
|
|
416
|
+
}
|
|
417
|
+
for (i2 = Math.max(i2, wi);i2 < s; ++i2) {
|
|
418
|
+
syms[li++] = dat[i2];
|
|
419
|
+
++lf[dat[i2]];
|
|
420
|
+
}
|
|
421
|
+
pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
|
|
422
|
+
if (!lst) {
|
|
423
|
+
st.r = pos & 7 | w[pos / 8 | 0] << 3;
|
|
424
|
+
pos -= 7;
|
|
425
|
+
st.h = head, st.p = prev, st.i = i2, st.w = wi;
|
|
426
|
+
}
|
|
427
|
+
} else {
|
|
428
|
+
for (var i2 = st.w || 0;i2 < s + lst; i2 += 65535) {
|
|
429
|
+
var e = i2 + 65535;
|
|
430
|
+
if (e >= s) {
|
|
431
|
+
w[pos / 8 | 0] = lst;
|
|
432
|
+
e = s;
|
|
433
|
+
}
|
|
434
|
+
pos = wfblk(w, pos + 1, dat.subarray(i2, e));
|
|
435
|
+
}
|
|
436
|
+
st.i = s;
|
|
437
|
+
}
|
|
438
|
+
return slc(o, 0, pre + shft(pos) + post);
|
|
439
|
+
};
|
|
440
|
+
var crct = /* @__PURE__ */ function() {
|
|
441
|
+
var t = new Int32Array(256);
|
|
442
|
+
for (var i2 = 0;i2 < 256; ++i2) {
|
|
443
|
+
var c = i2, k = 9;
|
|
444
|
+
while (--k)
|
|
445
|
+
c = (c & 1 && -306674912) ^ c >>> 1;
|
|
446
|
+
t[i2] = c;
|
|
447
|
+
}
|
|
448
|
+
return t;
|
|
449
|
+
}();
|
|
450
|
+
var crc = function() {
|
|
451
|
+
var c = -1;
|
|
452
|
+
return {
|
|
453
|
+
p: function(d) {
|
|
454
|
+
var cr = c;
|
|
455
|
+
for (var i2 = 0;i2 < d.length; ++i2)
|
|
456
|
+
cr = crct[cr & 255 ^ d[i2]] ^ cr >>> 8;
|
|
457
|
+
c = cr;
|
|
458
|
+
},
|
|
459
|
+
d: function() {
|
|
460
|
+
return ~c;
|
|
461
|
+
}
|
|
462
|
+
};
|
|
463
|
+
};
|
|
464
|
+
var dopt = function(dat, opt, pre, post, st) {
|
|
465
|
+
if (!st) {
|
|
466
|
+
st = { l: 1 };
|
|
467
|
+
if (opt.dictionary) {
|
|
468
|
+
var dict = opt.dictionary.subarray(-32768);
|
|
469
|
+
var newDat = new u8(dict.length + dat.length);
|
|
470
|
+
newDat.set(dict);
|
|
471
|
+
newDat.set(dat, dict.length);
|
|
472
|
+
dat = newDat;
|
|
473
|
+
st.w = dict.length;
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
|
|
477
|
+
};
|
|
478
|
+
var mrg = function(a, b) {
|
|
479
|
+
var o = {};
|
|
480
|
+
for (var k in a)
|
|
481
|
+
o[k] = a[k];
|
|
482
|
+
for (var k in b)
|
|
483
|
+
o[k] = b[k];
|
|
484
|
+
return o;
|
|
485
|
+
};
|
|
486
|
+
var wbytes = function(d, b, v) {
|
|
487
|
+
for (;v; ++b)
|
|
488
|
+
d[b] = v, v >>>= 8;
|
|
489
|
+
};
|
|
490
|
+
function deflateSync(data, opts) {
|
|
491
|
+
return dopt(data, opts || {}, 0, 0);
|
|
492
|
+
}
|
|
493
|
+
var fltn = function(d, p, t, o) {
|
|
494
|
+
for (var k in d) {
|
|
495
|
+
var val = d[k], n = p + k, op = o;
|
|
496
|
+
if (Array.isArray(val))
|
|
497
|
+
op = mrg(o, val[1]), val = val[0];
|
|
498
|
+
if (ArrayBuffer.isView(val))
|
|
499
|
+
t[n] = [val, op];
|
|
500
|
+
else {
|
|
501
|
+
t[n += "/"] = [new u8(0), op];
|
|
502
|
+
fltn(val, n, t, o);
|
|
503
|
+
}
|
|
504
|
+
}
|
|
505
|
+
};
|
|
506
|
+
var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder;
|
|
507
|
+
var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
|
|
508
|
+
var tds = 0;
|
|
509
|
+
try {
|
|
510
|
+
td.decode(et, { stream: true });
|
|
511
|
+
tds = 1;
|
|
512
|
+
} catch (e) {}
|
|
513
|
+
function strToU8(str, latin1) {
|
|
514
|
+
if (latin1) {
|
|
515
|
+
var ar_1 = new u8(str.length);
|
|
516
|
+
for (var i2 = 0;i2 < str.length; ++i2)
|
|
517
|
+
ar_1[i2] = str.charCodeAt(i2);
|
|
518
|
+
return ar_1;
|
|
519
|
+
}
|
|
520
|
+
if (te)
|
|
521
|
+
return te.encode(str);
|
|
522
|
+
var l = str.length;
|
|
523
|
+
var ar = new u8(str.length + (str.length >> 1));
|
|
524
|
+
var ai = 0;
|
|
525
|
+
var w = function(v) {
|
|
526
|
+
ar[ai++] = v;
|
|
527
|
+
};
|
|
528
|
+
for (var i2 = 0;i2 < l; ++i2) {
|
|
529
|
+
if (ai + 5 > ar.length) {
|
|
530
|
+
var n = new u8(ai + 8 + (l - i2 << 1));
|
|
531
|
+
n.set(ar);
|
|
532
|
+
ar = n;
|
|
533
|
+
}
|
|
534
|
+
var c = str.charCodeAt(i2);
|
|
535
|
+
if (c < 128 || latin1)
|
|
536
|
+
w(c);
|
|
537
|
+
else if (c < 2048)
|
|
538
|
+
w(192 | c >> 6), w(128 | c & 63);
|
|
539
|
+
else if (c > 55295 && c < 57344)
|
|
540
|
+
c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
|
|
541
|
+
else
|
|
542
|
+
w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
|
|
543
|
+
}
|
|
544
|
+
return slc(ar, 0, ai);
|
|
545
|
+
}
|
|
546
|
+
var exfl = function(ex) {
|
|
547
|
+
var le = 0;
|
|
548
|
+
if (ex) {
|
|
549
|
+
for (var k in ex) {
|
|
550
|
+
var l = ex[k].length;
|
|
551
|
+
if (l > 65535)
|
|
552
|
+
err(9);
|
|
553
|
+
le += l + 4;
|
|
554
|
+
}
|
|
555
|
+
}
|
|
556
|
+
return le;
|
|
557
|
+
};
|
|
558
|
+
var wzh = function(d, b, f, fn, u, c, ce, co) {
|
|
559
|
+
var fl2 = fn.length, ex = f.extra, col = co && co.length;
|
|
560
|
+
var exl = exfl(ex);
|
|
561
|
+
wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
|
|
562
|
+
if (ce != null)
|
|
563
|
+
d[b++] = 20, d[b++] = f.os;
|
|
564
|
+
d[b] = 20, b += 2;
|
|
565
|
+
d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
|
|
566
|
+
d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
|
|
567
|
+
var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
|
|
568
|
+
if (y < 0 || y > 119)
|
|
569
|
+
err(10);
|
|
570
|
+
wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
|
|
571
|
+
if (c != -1) {
|
|
572
|
+
wbytes(d, b, f.crc);
|
|
573
|
+
wbytes(d, b + 4, c < 0 ? -c - 2 : c);
|
|
574
|
+
wbytes(d, b + 8, f.size);
|
|
575
|
+
}
|
|
576
|
+
wbytes(d, b + 12, fl2);
|
|
577
|
+
wbytes(d, b + 14, exl), b += 16;
|
|
578
|
+
if (ce != null) {
|
|
579
|
+
wbytes(d, b, col);
|
|
580
|
+
wbytes(d, b + 6, f.attrs);
|
|
581
|
+
wbytes(d, b + 10, ce), b += 14;
|
|
582
|
+
}
|
|
583
|
+
d.set(fn, b);
|
|
584
|
+
b += fl2;
|
|
585
|
+
if (exl) {
|
|
586
|
+
for (var k in ex) {
|
|
587
|
+
var exf = ex[k], l = exf.length;
|
|
588
|
+
wbytes(d, b, +k);
|
|
589
|
+
wbytes(d, b + 2, l);
|
|
590
|
+
d.set(exf, b + 4), b += 4 + l;
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
if (col)
|
|
594
|
+
d.set(co, b), b += col;
|
|
595
|
+
return b;
|
|
596
|
+
};
|
|
597
|
+
var wzf = function(o, b, c, d, e) {
|
|
598
|
+
wbytes(o, b, 101010256);
|
|
599
|
+
wbytes(o, b + 8, c);
|
|
600
|
+
wbytes(o, b + 10, c);
|
|
601
|
+
wbytes(o, b + 12, d);
|
|
602
|
+
wbytes(o, b + 16, e);
|
|
603
|
+
};
|
|
604
|
+
function zipSync(data, opts) {
|
|
605
|
+
if (!opts)
|
|
606
|
+
opts = {};
|
|
607
|
+
var r = {};
|
|
608
|
+
var files = [];
|
|
609
|
+
fltn(data, "", r, opts);
|
|
610
|
+
var o = 0;
|
|
611
|
+
var tot = 0;
|
|
612
|
+
for (var fn in r) {
|
|
613
|
+
var _a2 = r[fn], file = _a2[0], p = _a2[1];
|
|
614
|
+
var compression = p.level == 0 ? 0 : 8;
|
|
615
|
+
var f = strToU8(fn), s = f.length;
|
|
616
|
+
var com = p.comment, m = com && strToU8(com), ms = m && m.length;
|
|
617
|
+
var exl = exfl(p.extra);
|
|
618
|
+
if (s > 65535)
|
|
619
|
+
err(11);
|
|
620
|
+
var d = compression ? deflateSync(file, p) : file, l = d.length;
|
|
621
|
+
var c = crc();
|
|
622
|
+
c.p(file);
|
|
623
|
+
files.push(mrg(p, {
|
|
624
|
+
size: file.length,
|
|
625
|
+
crc: c.d(),
|
|
626
|
+
c: d,
|
|
627
|
+
f,
|
|
628
|
+
m,
|
|
629
|
+
u: s != fn.length || m && com.length != ms,
|
|
630
|
+
o,
|
|
631
|
+
compression
|
|
632
|
+
}));
|
|
633
|
+
o += 30 + s + exl + l;
|
|
634
|
+
tot += 76 + 2 * (s + exl) + (ms || 0) + l;
|
|
635
|
+
}
|
|
636
|
+
var out = new u8(tot + 22), oe = o, cdl = tot - o;
|
|
637
|
+
for (var i2 = 0;i2 < files.length; ++i2) {
|
|
638
|
+
var f = files[i2];
|
|
639
|
+
wzh(out, f.o, f, f.f, f.u, f.c.length);
|
|
640
|
+
var badd = 30 + f.f.length + exfl(f.extra);
|
|
641
|
+
out.set(f.c, f.o + badd);
|
|
642
|
+
wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
|
|
643
|
+
}
|
|
644
|
+
wzf(out, o, files.length, cdl, oe);
|
|
645
|
+
return out;
|
|
646
|
+
}
|
|
647
|
+
|
|
648
|
+
// src/cli.ts
|
|
649
|
+
var BUILD_DIR_CANDIDATES = [
|
|
650
|
+
"dist",
|
|
651
|
+
"build",
|
|
652
|
+
"out",
|
|
653
|
+
".output/public",
|
|
654
|
+
".vercel/output/static",
|
|
655
|
+
"public",
|
|
656
|
+
"_site"
|
|
657
|
+
];
|
|
658
|
+
async function resolveDeployDir(opts = {}) {
|
|
659
|
+
if (opts.explicit)
|
|
660
|
+
return opts.explicit;
|
|
661
|
+
const cwd = opts.cwd ?? process.cwd();
|
|
662
|
+
for (const candidate of BUILD_DIR_CANDIDATES) {
|
|
663
|
+
const dir = join(cwd, candidate);
|
|
664
|
+
try {
|
|
665
|
+
if (!(await stat(dir)).isDirectory())
|
|
666
|
+
continue;
|
|
667
|
+
if ((await stat(join(dir, "index.html"))).isFile())
|
|
668
|
+
return dir;
|
|
669
|
+
} catch {}
|
|
670
|
+
}
|
|
671
|
+
throw new Error(`No build output folder found. Looked for ${BUILD_DIR_CANDIDATES.join(", ")} ` + `(each must contain an index.html). Pass the folder explicitly, e.g. \`npx flypod ./dist\`.`);
|
|
672
|
+
}
|
|
673
|
+
async function collectDist(dir) {
|
|
674
|
+
const files = {};
|
|
675
|
+
async function walk(current) {
|
|
676
|
+
for (const entry of await readdir(current, { withFileTypes: true })) {
|
|
677
|
+
const full = join(current, entry.name);
|
|
678
|
+
if (entry.isDirectory())
|
|
679
|
+
await walk(full);
|
|
680
|
+
else
|
|
681
|
+
files[relative(dir, full).split("\\").join("/")] = await readFile(full);
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
await walk(dir);
|
|
685
|
+
return files;
|
|
686
|
+
}
|
|
687
|
+
async function deploySite(opts) {
|
|
688
|
+
const handle = opts.handle ?? ((request) => fetch(request));
|
|
689
|
+
const baseUrl = opts.baseUrl ?? "https://flypod.dev";
|
|
690
|
+
const zip = zipSync(opts.files);
|
|
691
|
+
const res = await handle(new Request(`${baseUrl}/sites`, {
|
|
692
|
+
method: "POST",
|
|
693
|
+
headers: { "content-type": "application/zip" },
|
|
694
|
+
body: zip
|
|
695
|
+
}));
|
|
696
|
+
if (!res.ok)
|
|
697
|
+
throw new Error(`deploy failed: ${res.status}`);
|
|
698
|
+
return await res.json();
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
export { BUILD_DIR_CANDIDATES, resolveDeployDir, collectDist, deploySite };
|
package/dist/src/cli.js
ADDED
package/package.json
ADDED
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "flypod",
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "Zero-auth, agent-native deploy primitive — drop files, get a URL back",
|
|
5
|
+
"module": "src/cli.ts",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"license": "MIT",
|
|
8
|
+
"exports": {
|
|
9
|
+
".": "./dist/src/cli.js"
|
|
10
|
+
},
|
|
11
|
+
"bin": {
|
|
12
|
+
"flypod": "dist/bin/deploy.js"
|
|
13
|
+
},
|
|
14
|
+
"files": [
|
|
15
|
+
"dist",
|
|
16
|
+
"README.md",
|
|
17
|
+
"LICENSE"
|
|
18
|
+
],
|
|
19
|
+
"repository": {
|
|
20
|
+
"type": "git",
|
|
21
|
+
"url": "git+https://github.com/sdserranog/flypod.git",
|
|
22
|
+
"directory": "packages/flypod"
|
|
23
|
+
},
|
|
24
|
+
"keywords": [
|
|
25
|
+
"deploy",
|
|
26
|
+
"agent",
|
|
27
|
+
"ai",
|
|
28
|
+
"cli",
|
|
29
|
+
"static",
|
|
30
|
+
"hosting",
|
|
31
|
+
"cloudflare",
|
|
32
|
+
"workers"
|
|
33
|
+
],
|
|
34
|
+
"scripts": {
|
|
35
|
+
"build": "rm -rf dist && bun build src/cli.ts bin/deploy.ts --outdir dist --target node --splitting",
|
|
36
|
+
"test": "bun test",
|
|
37
|
+
"typecheck": "tsc --noEmit",
|
|
38
|
+
"deploy": "wrangler deploy",
|
|
39
|
+
"dev": "bun --hot index.ts"
|
|
40
|
+
},
|
|
41
|
+
"dependencies": {
|
|
42
|
+
"fflate": "^0.8.3",
|
|
43
|
+
"hono": "^4.12.25",
|
|
44
|
+
"marked": "^18.0.5"
|
|
45
|
+
},
|
|
46
|
+
"devDependencies": {
|
|
47
|
+
"@libsql/client": "^0.17.3",
|
|
48
|
+
"@types/bun": "latest",
|
|
49
|
+
"better-auth": "^1.6.14",
|
|
50
|
+
"playwright": "^1.60.0",
|
|
51
|
+
"typescript": "^6.0.3",
|
|
52
|
+
"wrangler": "^4.0.0"
|
|
53
|
+
},
|
|
54
|
+
"peerDependencies": {
|
|
55
|
+
"typescript": "^6.0.3"
|
|
56
|
+
}
|
|
57
|
+
}
|