schrun 0.0.0-stage → 0.1.0

package/CLAUDE.md

@@ -0,0 +1,106 @@
+
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Use `bunx <package> <command>` instead of `npx <package> <command>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
+- Bun.$`ls` instead of execa.
+
+## Testing
+
+Use `bun test` to run tests.
+
+```ts#index.test.ts
+import { test, expect } from "bun:test";
+
+test("hello world", () => {
+  expect(1).toBe(1);
+});
+```
+
+## Frontend
+
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+
+Server:
+
+```ts#index.ts
+import index from "./index.html"
+
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+
+With the following `frontend.tsx`:
+
+```tsx#frontend.tsx
+import React from "react";
+import { createRoot } from "react-dom/client";
+
+// import .css files directly and it works
+import './index.css';
+
+const root = createRoot(document.body);
+
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+
+root.render(<Frontend />);
+```
+
+Then, run index.ts
+
+```sh
+bun --hot ./index.ts
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.mdx`.

package/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to schrun
+
+Thanks for your interest in contributing to `schrun`! Contributions such as bug reports, documentation improvements, and focused code changes are welcome.
+
+## Getting started
+
+- Install [Bun](https://bun.sh/).
+- Clone the repository and work from its root directory.
+- Install workspace dependencies:
+
+  ```bash
+  bun install
+  ```
+
+## Making changes
+
+1. Create a branch for your change.
+2. Keep changes focused and follow the existing TypeScript style and project conventions.
+3. Update the documentation when behavior or usage changes.
+4. Run the relevant checks before opening a pull request.
+
+The CLI entry point is `apps/schrun/src/index.ts`. You can run it from the repository root with:
+
+```bash
+bun run apps/schrun/src/index.ts --help
+```
+
+## Testing
+
+There is currently no test script configured for this app. For changes that affect CLI behavior, manually verify the relevant command using a temporary task file under `~/.config/schrun/`. Avoid committing personal configuration or credentials.
+
+## Pull requests
+
+When opening a pull request, please include:
+
+- A concise description of the problem and the proposed change.
+- Any relevant usage or behavior changes.
+- The checks or manual verification you performed.
+
+Keep pull requests focused and be open to feedback during review.

package/LICENSE

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

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# schrun
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`schrun` is a small task runner for launching commands defined in JSON files. It supports running a task in the foreground or starting it as a detached background process.
+
+## Requirements
+
+- [Bun](https://bun.sh/)
+
+## Installation
+
+From the repository root, install the workspace dependencies:
+
+```bash
+bun install
+```
+
+## Configure a task
+
+Create the configuration directory and a JSON file inside it. The file name is the task identifier passed to `schrun` (it does not need a `.json` extension).
+
+```bash
+mkdir -p ~/.config/schrun
+```
+
+For example, save the following as `~/.config/schrun/hello.json`:
+
+```json
+{
+  "id": 1,
+  "description": "Print a greeting",
+  "run": "echo hello"
+}
+```
+
+Each task file must contain:
+
+- `id`: a number
+- `description`: a string
+- `run`: a command and its arguments, separated by whitespace
+
+## Run a task
+
+Run from the repository root:
+
+```bash
+bun run apps/schrun/src/index.ts hello.json
+```
+
+The command inherits the terminal's standard input and output, and `schrun` waits for it to finish.
+
+To start it detached in the background:
+
+```bash
+bun run apps/schrun/src/index.ts --background hello.json
+```
+
+Background tasks have their standard input and output ignored; `schrun` returns after starting the process.
+
+## Limitations
+
+The `run` value is split on whitespace and launched directly, without a shell. Shell features such as pipes, redirects, variable expansion, and quoted arguments are not interpreted.

package/dist/index.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { cli, define } from "gunshi";
+import { readFile } from "node:fs/promises";
+import { consola } from "consola";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+//#region src/version.ts
+const version = async () => {
+	const packageJsonText = await readFile(new URL("../package.json", import.meta.url), "utf-8");
+	return JSON.parse(packageJsonText).version;
+};
+//#endregion
+//#region src/constant/app.ts
+const CLI_COMMAND_NAME = "schrun";
+const CONFIG_DIR = join(`${homedir()}`, ".config", "schrun");
+//#endregion
+//#region src/type.ts
+const fileSchema = z.object({
+	id: z.number(),
+	description: z.string(),
+	run: z.string()
+});
+//#endregion
+//#region src/read.ts
+const readFiles = async (FileName) => {
+	const file = join(CONFIG_DIR, `${FileName}.json`);
+	const reads = await readFile(file, "utf-8");
+	const safeParseSchema = fileSchema.safeParse(JSON.parse(reads));
+	if (!safeParseSchema.success) throw consola.error(safeParseSchema.error);
+	return safeParseSchema.data;
+};
+//#endregion
+//#region src/run/background.ts
+const runbackground = async (FileName) => {
+	const [command, ...args] = (await readFiles(FileName)).run.split(/\s+/);
+	if (!command) {
+		consola.error("do not run commands");
+		return;
+	}
+	const spawncli = spawn(command, args, {
+		stdio: "ignore",
+		detached: true
+	});
+	spawncli.on("error", (error) => {
+		consola.error("failed to start processing", error);
+	});
+	spawncli.unref();
+};
+//#endregion
+//#region src/run/surface.ts
+const runsurface = async (FileName) => {
+	const [command, ...args] = (await readFiles(FileName)).run.split(/\s+/);
+	if (!command) {
+		consola.error("do not run commands");
+		return;
+	}
+	const spawncli = spawn(command, args, { stdio: "inherit" });
+	spawncli.on("error", (error) => {
+		consola.error("failed run command", error);
+	});
+	spawncli.on("close", (code) => {
+		consola.success(`done code: ${code}`);
+	});
+};
+//#endregion
+//#region src/index.ts
+const mainCommand = define({
+	name: CLI_COMMAND_NAME,
+	description: "agent and other task runner",
+	version: await version(),
+	args: {
+		defaultInput: {
+			type: "positional",
+			required: false,
+			description: "Input value"
+		},
+		background: {
+			type: "string",
+			required: false,
+			description: "Run a task in the background"
+		}
+	},
+	run: async (ctx) => {
+		const { defaultInput, background } = ctx.values;
+		if (background !== void 0) {
+			console.log("Background mode:", background);
+			await runbackground(background);
+			return;
+		}
+		if (defaultInput !== void 0) {
+			console.log("Normal mode:", defaultInput);
+			await runsurface(defaultInput);
+			return;
+		}
+		consola.error("No Input String");
+	}
+});
+await cli(process.argv.slice(2), mainCommand, {});
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "schrun",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "module": "src/index.ts",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "schrun": "./dist/index.mjs"
+  },
+  "url": "https://github.com/nazozokc/schrun",
+  "author": {
+    "name": "nazozokc",
+    "url": "https://github.com/nazozokc"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsdown": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^7"
+  },
+  "dependencies": {
+    "consola": "^3.4.2",
+    "execa": "^10.1.0",
+    "gunshi": "^0.37.3",
+    "zod": "^4.6.7"
+  }
+}

package/src/constant/app.ts

@@ -0,0 +1,5 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export const CLI_COMMAND_NAME = "schrun";
+export const CONFIG_DIR = join(`${homedir()}`, ".config", "schrun");

package/src/index.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { cli, define } from "gunshi";
+import { version } from "./version.ts";
+import { runbackground } from "./run/background.ts";
+import { runsurface } from "./run/surface.ts";
+import { consola } from "consola";
+import { CLI_COMMAND_NAME } from "./constant/app.ts";
+
+const mainCommand = define({
+  name: CLI_COMMAND_NAME,
+  description: "agent and other task runner",
+  version: await version(),
+
+  args: {
+    defaultInput: {
+      type: "positional",
+      required: false,
+      description: "Input value",
+    },
+
+    background: {
+      type: "string",
+      required: false,
+      description: "Run a task in the background",
+    },
+  },
+
+  run: async (ctx) => {
+    const { defaultInput, background } = ctx.values;
+
+    if (background !== undefined) {
+      console.log("Background mode:", background);
+      await runbackground(background);
+      return;
+    }
+
+    if (defaultInput !== undefined) {
+      console.log("Normal mode:", defaultInput);
+      await runsurface(defaultInput);
+      return;
+    }
+
+    consola.error("No Input String");
+    return;
+  },
+});
+
+await cli(process.argv.slice(2), mainCommand, {});

package/src/read.ts

@@ -0,0 +1,18 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_DIR } from "./constant/app";
+import { fileSchema, type FileType } from "./type";
+import { consola } from "consola";
+
+export const readFiles = async (FileName: string): Promise<FileType> => {
+  const file = join(CONFIG_DIR, `${FileName}.json`);
+  const reads = await readFile(file, "utf-8");
+
+  const safeParseSchema = fileSchema.safeParse(JSON.parse(reads));
+
+  if (!safeParseSchema.success) {
+    throw consola.error(safeParseSchema.error);
+  }
+
+  return safeParseSchema.data as FileType;
+};

package/src/run/background.ts

@@ -0,0 +1,26 @@
+import { consola } from "consola";
+import { readFiles } from "../read.ts";
+import { spawn } from "node:child_process";
+
+export const runbackground = async (FileName: string): Promise<void> => {
+  const reads = await readFiles(FileName);
+  const commandsplit = reads.run.split(/\s+/);
+
+  const [command, ...args] = commandsplit;
+
+  if (!command) {
+    consola.error("do not run commands");
+    return;
+  }
+
+  const spawncli = spawn(command, args, {
+    stdio: "ignore",
+    detached: true,
+  });
+
+  spawncli.on("error", (error) => {
+    consola.error("failed to start processing", error);
+  });
+
+  spawncli.unref();
+};

package/src/run/surface.ts

@@ -0,0 +1,27 @@
+import { consola } from "consola";
+import { readFiles } from "../read.ts";
+import { spawn } from "node:child_process";
+
+export const runsurface = async (FileName: string): Promise<void> => {
+  const reads = await readFiles(FileName);
+  const commandsplit = reads.run.split(/\s+/);
+
+  const [command, ...args] = commandsplit;
+
+  if (!command) {
+    consola.error("do not run commands");
+    return;
+  }
+
+  const spawncli = spawn(command, args, {
+    stdio: "inherit",
+  });
+
+  spawncli.on("error", (error) => {
+    consola.error("failed run command", error);
+  });
+
+  spawncli.on("close", (code) => {
+    consola.success(`done code: ${code}`);
+  });
+};

package/src/type.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const fileSchema = z.object({
+  id: z.number(),
+  description: z.string(),
+  run: z.string(),
+});
+
+export type FileType = z.infer<typeof fileSchema>;

package/src/version.ts

@@ -0,0 +1,15 @@
+import { readFile } from "node:fs/promises";
+
+type packagejson = {
+  version: string;
+};
+
+export const version = async (): Promise<string> => {
+  const packageJsonText = await readFile(
+    new URL("../package.json", import.meta.url),
+    "utf-8",
+  );
+  const packageJson: packagejson = JSON.parse(packageJsonText);
+
+  return packageJson.version;
+};

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}