void 0.1.6 → 0.7.0

package/skills/void/docs/node_modules/void/node_modules/@clack/prompts/README.md

@@ -0,0 +1,375 @@
+# `@clack/prompts`
+
+Effortlessly build beautiful command-line apps 🪄 [Try the demo](https://stackblitz.com/edit/clack-prompts?file=index.js)
+
+![clack-prompt](https://github.com/bombshell-dev/clack/blob/main/.github/assets/clack-demo.gif)
+
+---
+
+`@clack/prompts` is an opinionated, pre-styled wrapper around [`@clack/core`](https://www.npmjs.com/package/@clack/core).
+
+- 🤏 80% smaller than other options
+- 💎 Beautiful, minimal UI
+- ✅ Simple API
+- 🧱 Comes with `text`, `password`, `confirm`, `date`, `select`, `autocomplete`, `selectKey`, `multiselect`, `path`, and `spinner` components
+
+## Basics
+
+### Setup
+
+The `intro` and `outro` functions will print a message to begin or end a prompt session, respectively.
+
+```js
+import { intro, outro } from '@clack/prompts';
+
+intro(`create-my-app`);
+// Do stuff
+outro(`You're all set!`);
+```
+
+### Cancellation
+
+The `isCancel` function is a guard that detects when a user cancels a question with `CTRL + C`. You should handle this situation for each prompt, optionally providing a nice cancellation message with the `cancel` utility.
+
+```js
+import { isCancel, cancel, text } from '@clack/prompts';
+
+const value = await text({
+  message: 'What is the meaning of life?',
+});
+
+if (isCancel(value)) {
+  cancel('Operation cancelled.');
+  process.exit(0);
+}
+```
+
+## Components
+
+### Text
+
+The text component accepts a single line of text.
+
+```js
+import { text } from '@clack/prompts';
+
+const meaning = await text({
+  message: 'What is the meaning of life?',
+  placeholder: 'Not sure',
+  initialValue: '42',
+  validate(value) {
+    if (value.length === 0) return `Value is required!`;
+  },
+});
+```
+
+### Password
+
+The password component behaves like `text`, but masks the input as the user types.
+
+```js
+import { password } from '@clack/prompts';
+
+const secret = await password({
+  message: 'Set a password.',
+  mask: '*',
+  validate(value) {
+    if (!value || value.length < 8) return 'Password must be at least 8 characters.';
+  },
+});
+```
+
+### Confirm
+
+The confirm component accepts a yes or no answer. The result is a boolean value of `true` or `false`.
+
+```js
+import { confirm } from '@clack/prompts';
+
+const shouldContinue = await confirm({
+  message: 'Do you want to continue?',
+});
+```
+
+### Date
+
+The date component accepts a calendar date and returns a `Date` value.
+
+```js
+import { date } from '@clack/prompts';
+
+const dueDate = await date({
+  message: 'Pick a due date.',
+  format: 'YMD',
+  minDate: new Date(Date.UTC(2026, 0, 1)),
+  maxDate: new Date(Date.UTC(2026, 11, 31)),
+});
+```
+
+### Select
+
+The select component allows a user to choose one value from a list of options. The result is the `value` prop of a given option.
+
+```js
+import { select } from '@clack/prompts';
+
+const projectType = await select({
+  message: 'Pick a project type.',
+  options: [
+    { value: 'ts', label: 'TypeScript' },
+    { value: 'js', label: 'JavaScript', disabled: true },
+    { value: 'coffee', label: 'CoffeeScript', hint: 'oh no' },
+  ],
+});
+```
+
+### Autocomplete
+
+The autocomplete component lets a user filter a list by typing, then choose one option from the matching results. By default, matching uses each option's `label`, `hint`, and `value`. The result is the selected option's `value`.
+
+```js
+import { autocomplete } from '@clack/prompts';
+
+const framework = await autocomplete({
+  message: 'Pick a framework.',
+  placeholder: 'Type to search...',
+  options: [
+    { value: 'next', label: 'Next.js' },
+    { value: 'nuxt', label: 'Nuxt' },
+    { value: 'sveltekit', label: 'SvelteKit' },
+    { value: 'remix', label: 'Remix' },
+  ],
+});
+```
+
+### Select Key
+
+The `selectKey` component lets a user choose an option by pressing its single-character string `value` key directly.
+
+```js
+import { selectKey } from '@clack/prompts';
+
+const action = await selectKey({
+  message: 'Pick an action.',
+  options: [
+    { value: 'd', label: 'Deploy' },
+    { value: 't', label: 'Run tests' },
+    { value: 'q', label: 'Quit' },
+  ],
+});
+```
+
+### Multi-Select
+
+The `multiselect` component allows a user to choose many values from a list of options. The result is an array with all selected `value` props.
+
+```js
+import { multiselect } from '@clack/prompts';
+
+const additionalTools = await multiselect({
+  message: 'Select additional tools.',
+  options: [
+    { value: 'eslint', label: 'ESLint', hint: 'recommended' },
+    { value: 'prettier', label: 'Prettier', disabled: true },
+    { value: 'gh-action', label: 'GitHub Action' },
+  ],
+  required: false,
+});
+```
+
+It is also possible to select multiple items arranged into hierarchy by using `groupMultiselect`:
+
+```js
+import { groupMultiselect } from '@clack/prompts';
+
+const basket = await groupMultiselect({
+  message: 'Select your favorite fruits and vegetables:',
+  options: {
+    fruits: [
+      { value: 'apple', label: 'apple' },
+      { value: 'banana', label: 'banana' },
+      { value: 'cherry', label: 'cherry' },
+    ],
+    vegetables: [
+      { value: 'carrot', label: 'carrot' },
+      { value: 'spinach', label: 'spinach' },
+      { value: 'potato', label: 'potato' },
+    ]
+  }
+});
+```
+
+### Multi-Line Text
+
+The multi-line text component accepts multiple lines of text input. By default, pressing `Enter` twice submits the input.
+
+```js
+import { multiline } from '@clack/prompts';
+
+const bio = await multiline({
+  message: 'Tell us about yourself.',
+  placeholder: 'Start typing...',
+  validate(value) {
+    if (value.length === 0) return `value is required`;
+  },
+});
+```
+
+Set `showSubmit` to display an explicit submit button instead of double `Enter` submission:
+
+```js
+const bio = await multiline({
+  message: 'Tell us about yourself.',
+  showSubmit: true,
+});
+```
+
+### Path
+
+The path component offers filesystem path suggestions and returns the selected path as a string. When `directory: true` is set, only directories can be selected.
+
+```js
+import { path } from '@clack/prompts';
+
+const targetDir = await path({
+  message: 'Select an existing directory.',
+  directory: true,
+});
+```
+
+### Spinner
+
+The spinner component surfaces a pending action, such as a long-running download or dependency installation.
+
+```js
+import { spinner } from '@clack/prompts';
+
+const s = spinner();
+s.start('Installing via npm');
+// Do installation here
+s.stop('Installed via npm');
+```
+
+### Progress
+
+The progress component extends the spinner component to add a progress bar to visualize the progression of an action.
+
+```js
+import { progress } from '@clack/prompts';
+
+const p = progress({ max: 10 });
+p.start('Downloading archive');
+// Do download here
+p.advance(3, 'Downloading (30%)');
+// ...
+p.advance(5, 'Downloading (80%)');
+// ...
+p.stop('Archive downloaded');
+```
+
+## Utilities
+
+### Grouping
+
+Grouping prompts together is a great way to keep your code organized. This accepts a JSON object with a name that can be used to reference the group later. The second argument is an optional but has a `onCancel` callback that will be called if the user cancels one of the prompts in the group.
+
+```js
+import * as p from '@clack/prompts';
+
+const group = await p.group(
+  {
+    name: () => p.text({ message: 'What is your name?' }),
+    age: () => p.text({ message: 'What is your age?' }),
+    color: ({ results }) =>
+      p.multiselect({
+        message: `What is your favorite color ${results.name}?`,
+        options: [
+          { value: 'red', label: 'Red' },
+          { value: 'green', label: 'Green' },
+          { value: 'blue', label: 'Blue' },
+        ],
+      }),
+  },
+  {
+    // On Cancel callback that wraps the group
+    // So if the user cancels one of the prompts in the group this function will be called
+    onCancel: ({ results }) => {
+      p.cancel('Operation cancelled.');
+      process.exit(0);
+    },
+  }
+);
+
+console.log(group.name, group.age, group.color);
+```
+
+### Tasks
+
+Execute multiple tasks in spinners.
+
+```js
+import { tasks } from '@clack/prompts';
+
+await tasks([
+  {
+    title: 'Installing via npm',
+    task: async (message) => {
+      // Do installation here
+      return 'Installed via npm';
+    },
+  },
+]);
+```
+
+### Logs
+
+```js
+import { log } from '@clack/prompts';
+
+log.info('Info!');
+log.success('Success!');
+log.step('Step!');
+log.warn('Warn!');
+log.error('Error!');
+log.message('Hello, World', { symbol: color.cyan('~') });
+```
+
+
+### Stream
+
+When interacting with dynamic LLMs or other streaming message providers, use the `stream` APIs to log messages from an iterable, even an async one.
+
+```js
+import { stream } from '@clack/prompts';
+
+stream.info((function *() { yield 'Info!'; })());
+stream.success((function *() { yield 'Success!'; })());
+stream.step((function *() { yield 'Step!'; })());
+stream.warn((function *() { yield 'Warn!'; })());
+stream.error((function *() { yield 'Error!'; })());
+stream.message((function *() { yield 'Hello'; yield ", World" })(), { symbol: color.cyan('~') });
+```
+
+![clack-log-prompts](https://github.com/bombshell-dev/clack/blob/main/.github/assets/clack-logs.png)
+
+### Task Log
+
+When executing a sub-process or a similar sub-task, `taskLog` can be used to render the output continuously and clear it at the end if it was successful.
+
+```js
+import { taskLog } from '@clack/prompts';
+
+const log = taskLog({
+	title: 'Running npm install'
+});
+
+for await (const line of npmInstall()) {
+	log.message(line);
+}
+
+if (success) {
+	log.success('Done!');
+} else {
+	log.error('Failed!');
+}
+```

package/skills/void/docs/node_modules/void/node_modules/@cloudflare/sandbox/README.md

@@ -0,0 +1,174 @@
+<img width="1362" height="450" alt="Image" src="https://github.com/user-attachments/assets/6f770ae3-0a14-4d2b-9aed-a304ee5446c5" />
+
+# Cloudflare Sandbox SDK
+
+[![npm version](https://img.shields.io/npm/v/@cloudflare/sandbox)](https://www.npmjs.com/package/@cloudflare/sandbox)
+[![npm downloads](https://img.shields.io/npm/dw/@cloudflare/sandbox)](https://www.npmjs.com/package/@cloudflare/sandbox)
+
+**Build secure, isolated code execution environments on Cloudflare.**
+
+The Sandbox SDK lets you run untrusted code safely in isolated containers. Execute commands, manage files, run background processes, and expose services — all from your Workers applications.
+
+Perfect for AI code execution, interactive development environments, data analysis platforms, CI/CD systems, and any application that needs secure code execution at the edge.
+
+## Getting Started
+
+### Prerequisites
+
+1. Install [Node.js](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) (version 16.17.0 or later)
+2. Ensure Docker is running locally ([see setup guide](https://developers.cloudflare.com/sandbox/get-started/#ensure-docker-is-running-locally))
+3. For deploying to production, sign up for a [Cloudflare account](https://dash.cloudflare.com/sign-up/workers-and-pages)
+
+### 1. Create a new project
+
+Create a new Sandbox SDK project using the minimal template:
+
+```bash
+npm create cloudflare@latest -- my-sandbox --template=cloudflare/sandbox-sdk/examples/minimal
+cd my-sandbox
+```
+
+### 2. Test locally
+
+Start the development server:
+
+```bash
+npm run dev
+```
+
+> **Note:** First run builds the Docker container (2-3 minutes). Subsequent runs are much faster.
+
+Test the endpoints:
+
+```bash
+# Execute Python code
+curl http://localhost:8787/run
+
+# File operations
+curl http://localhost:8787/file
+```
+
+### 3. Deploy to production
+
+Deploy your Worker and container:
+
+```bash
+npx wrangler deploy
+```
+
+> **Wait for provisioning:** After first deployment, wait 2-3 minutes before making requests.
+
+**📖 [View the complete getting started guide](https://developers.cloudflare.com/sandbox/get-started/)** for detailed instructions and explanations.
+
+## Quick API Example
+
+```typescript
+import { getSandbox, proxyToSandbox, type Sandbox } from '@cloudflare/sandbox';
+
+export { Sandbox } from '@cloudflare/sandbox';
+
+type Env = {
+  Sandbox: DurableObjectNamespace<Sandbox>;
+};
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    // Required for preview URLs
+    const proxyResponse = await proxyToSandbox(request, env);
+    if (proxyResponse) return proxyResponse;
+
+    const url = new URL(request.url);
+    const sandbox = getSandbox(env.Sandbox, 'my-sandbox');
+
+    // Execute Python code
+    if (url.pathname === '/run') {
+      const result = await sandbox.exec('python3 -c "print(2 + 2)"');
+      return Response.json({ output: result.stdout, success: result.success });
+    }
+
+    // Work with files
+    if (url.pathname === '/file') {
+      await sandbox.writeFile('/workspace/hello.txt', 'Hello, Sandbox!');
+      const file = await sandbox.readFile('/workspace/hello.txt');
+      return Response.json({ content: file.content });
+    }
+
+    return new Response('Try /run or /file');
+  }
+};
+```
+
+## Documentation
+
+**📖 [Full Documentation](https://developers.cloudflare.com/sandbox/)**
+
+- [Get Started Guide](https://developers.cloudflare.com/sandbox/get-started/) - Step-by-step tutorial
+- [API Reference](https://developers.cloudflare.com/sandbox/api/) - Complete API docs
+- [Guides](https://developers.cloudflare.com/sandbox/guides/) - Execute commands, manage files, expose services
+- [Examples](https://developers.cloudflare.com/sandbox/tutorials/) - AI agents, data analysis, CI/CD pipelines
+
+## Key Features
+
+- **Secure Isolation** - Each sandbox runs in its own container
+- **Edge-Native** - Runs on Cloudflare's global network
+- **Code Interpreter** - Execute Python and JavaScript with rich outputs
+- **File System Access** - Read, write, and manage files
+- **Command Execution** - Run any command with streaming support
+- **Preview URLs** - Expose services with public URLs
+- **Git Integration** - Clone repositories directly
+
+## Contributing
+
+We welcome contributions from the community! See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines on:
+
+- Setting up your development environment
+- Creating pull requests
+- Code style and testing requirements
+
+## Development
+
+This repository contains the SDK source code. Quick start:
+
+```bash
+# Clone the repo
+git clone https://github.com/cloudflare/sandbox-sdk
+cd sandbox-sdk
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build the project
+npm run build
+
+# Type checking and linting
+npm run check
+```
+
+## Examples
+
+See the [examples directory](./examples) for complete working examples:
+
+- [Minimal](./examples/minimal) - Start here: exec commands, read/write files
+- [Code Interpreter](./examples/code-interpreter) - Give [gpt-oss](https://developers.cloudflare.com/workers-ai/models/gpt-oss-120b/) on Workers AI a Python REPL
+- [Claude Code](./examples/claude-code) - Run [Claude Code](https://claude.ai/code) headless on any repo
+- [OpenAI Agents](./examples/openai-agents) - `Shell` and `Editor` tools for [OpenAI Agents SDK](https://openai.github.io/openai-agents-js/)
+- [OpenCode](./examples/opencode) - [OpenCode](https://github.com/sst/opencode) web UI or [SDK](https://opencode.ai/docs/sdk/) in a sandbox
+- [TypeScript Validator](./examples/typescript-validator) - Build with npm in sandbox, execute in [isolates](https://developers.cloudflare.com/workers/runtime-apis/bindings/worker-loader/)
+
+## Status
+
+**Beta** - The SDK is in active development. APIs may change before v1.0.
+
+## License
+
+[Apache License 2.0](LICENSE)
+
+## Links
+
+- [Documentation](https://developers.cloudflare.com/sandbox/)
+- [GitHub Issues](https://github.com/cloudflare/sandbox-sdk/issues)
+- [Developer Discord](https://discord.cloudflare.com)
+- [Cloudflare Developers](https://twitter.com/CloudflareDev)

package/skills/void/docs/node_modules/void/node_modules/@cloudflare/vite-plugin/README.md

@@ -0,0 +1,37 @@
+# `@cloudflare/vite-plugin`
+
+The Cloudflare Vite plugin enables a full-featured integration between [Vite](https://vite.dev/) and the [Workers runtime](https://developers.cloudflare.com/workers/runtime-apis/).
+Your Worker code runs inside [workerd](https://github.com/cloudflare/workerd), matching the production behavior as closely as possible and providing confidence as you develop and deploy your applications.
+
+```ts
+// vite.config.ts
+
+import { defineConfig } from "vite";
+import { cloudflare } from "@cloudflare/vite-plugin";
+
+export default defineConfig({
+  plugins: [cloudflare()],
+});
+```
+
+## Documentation
+
+Full documentation can be found [here](https://developers.cloudflare.com/workers/vite-plugin/).
+
+## Features
+
+- Uses the Vite [Environment API](https://vite.dev/guide/api-environment) to integrate Vite with the Workers runtime
+- Provides direct access to [Workers runtime APIs](https://developers.cloudflare.com/workers/runtime-apis/) and [bindings](https://developers.cloudflare.com/workers/runtime-apis/bindings/)
+- Builds your front-end assets for deployment to Cloudflare, enabling you to build static sites, SPAs, and full-stack applications
+- Official support for [TanStack Start](https://tanstack.com/start/) and [React Router v7](https://reactrouter.com/) with server-side rendering
+- Leverages Vite's hot module replacement for consistently fast updates
+- Supports `vite preview` for previewing your build output in the Workers runtime prior to deployment
+
+## Use cases
+
+- [TanStack Start](https://tanstack.com/start/)
+- [React Router v7](https://reactrouter.com/)
+- Support for more full-stack frameworks is coming soon
+- Static sites, such as single-page applications, with or without an integrated backend API
+- Standalone Workers
+- Multi-Worker applications