schrun 0.0.0-stage → 0.2.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,158 @@
+#!/usr/bin/env node
+import { i as PID_FILE, n as CLI_COMMAND_NAME, t as readJSON } from "./readJSON-p8OldMa9.mjs";
+import { cli, define } from "gunshi";
+import { open, readFile, unlink, writeFile } from "node:fs/promises";
+import { consola } from "consola";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#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/run/background.ts
+const runbackground = async (FileName) => {
+	const [command, ...args] = (await readJSON(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 readJSON(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/run/startscheduler.ts
+const startschedule = async () => {
+	const daemonPath = fileURLToPath(new URL("./daemon.mjs", import.meta.url));
+	const logFile = await open("/tmp/schrun-daemon.log", "a");
+	const child = spawn(process.execPath, [daemonPath], {
+		detached: true,
+		stdio: [
+			"ignore",
+			logFile.fd,
+			logFile.fd
+		]
+	});
+	if (child.pid === void 0) {
+		await logFile.close();
+		throw new Error("Failed to start daemon");
+	}
+	child.on("error", (error) => {
+		console.error("Failed to start daemon:", error);
+	});
+	await writeFile(PID_FILE, String(child.pid));
+	child.unref();
+	await logFile.close();
+};
+//#endregion
+//#region src/run/stopscheduler.ts
+const stopschedule = async () => {
+	let pid;
+	try {
+		pid = Number(await readFile(PID_FILE, "utf-8"));
+	} catch {
+		consola.warn("no look schedule pid file");
+		return;
+	}
+	if (!Number.isSafeInteger(pid) || pid <= 0) {
+		consola.error("warning pid files");
+		return;
+	}
+	try {
+		process.kill(pid, "SIGINT");
+		consola.success("send stop to scheduler");
+	} catch (error) {
+		consola.error("failed stop to scheduler", error);
+		return;
+	}
+	await unlink(PID_FILE).catch(() => {});
+};
+//#endregion
+//#region src/commands/run/index.ts
+const runCommand = {
+	name: "run",
+	args: {
+		start: {
+			type: "boolean",
+			required: false,
+			description: "Start scheduler"
+		},
+		stop: {
+			type: "boolean",
+			required: false,
+			description: "Stop scheduler"
+		}
+	},
+	run: (ctx) => {
+		const { start, stop } = ctx.values;
+		if (start == true) startschedule();
+		if (stop == true) stopschedule();
+	}
+};
+//#endregion
+//#region src/commands/default/index.ts
+const mainCommand = async () => {
+	const RunmainCommand = 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), RunmainCommand, {
+		name: CLI_COMMAND_NAME,
+		subCommands: { run: runCommand }
+	});
+};
+//#endregion
+//#region src/index.ts
+await mainCommand();
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "schrun",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "module": "src/index.ts",
+  "version": "0.2.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",
+    "node-cron": "^4.6.0",
+    "zod": "^4.6.7"
+  }
+}

package/src/commands/default/index.ts

@@ -0,0 +1,55 @@
+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";
+import { runCommand } from "../run/index.ts";
+
+export const mainCommand = async (): Promise<void> => {
+  const RunmainCommand = 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), RunmainCommand, {
+    name: CLI_COMMAND_NAME,
+    subCommands: {
+      run: runCommand,
+    },
+  });
+};

package/src/commands/run/index.ts

@@ -0,0 +1,31 @@
+import type { Command } from "gunshi";
+import { startschedule } from "../../run/startscheduler.ts";
+import { stopschedule } from "../../run/stopscheduler.ts";
+
+export const runCommand: Command = {
+  name: "run",
+  args: {
+    start: {
+      type: "boolean",
+      required: false,
+      description: "Start scheduler",
+    },
+    stop: {
+      type: "boolean",
+      required: false,
+      description: "Stop scheduler",
+    },
+  },
+
+  run: (ctx) => {
+    const { start, stop } = ctx.values;
+
+    if (start == true) {
+      startschedule();
+    }
+
+    if (stop == true) {
+      stopschedule();
+    }
+  },
+};

package/src/constant/app.ts

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

package/src/index.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { mainCommand } from "./commands/default";
+
+await mainCommand();

package/src/readJSON.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 readJSON = 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 { readJSON } from "../readJSON.ts";
+import { spawn } from "node:child_process";
+
+export const runbackground = async (FileName: string): Promise<void> => {
+  const reads = await readJSON(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/daemon.ts

@@ -0,0 +1,39 @@
+import cron from "node-cron";
+import { spawn } from "node:child_process";
+import { readJSON } from "../readJSON.ts";
+import { readdir } from "node:fs/promises";
+import { CONFIG_DIR } from "../constant/app.ts";
+import { consola } from "consola";
+
+export const startschedule = async (): Promise<void> => {
+  const readConfig = await readdir(CONFIG_DIR);
+
+  for (const filename of readConfig) {
+    if (!filename.endsWith(".json")) continue;
+    if (!filename.match("foo.json")) continue;
+    const [filenamesplit] = filename.split(".");
+    const read = await readJSON(filenamesplit!);
+
+    if (!read.enabled) continue;
+
+    const [command, ...args] = read.run.trim().split(/\s+/);
+
+    if (!command) continue;
+
+    cron.schedule(read.cron, () => {
+      const cronspawn = spawn(command!, args!, {
+        detached: true,
+        stdio: "inherit",
+      });
+
+      cronspawn.on("error", (error) => {
+        consola.error(`コマンドの起動に失敗: ${command}`, error);
+      });
+    });
+  }
+};
+
+startschedule().catch((error) => {
+  consola.error("failed to up scheduler", error);
+  process.exitCode = 1;
+});

package/src/run/startscheduler.ts

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+import { open, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { PID_FILE } from "../constant/app.ts";
+
+export const startschedule = async (): Promise<void> => {
+  const daemonPath = fileURLToPath(new URL("./daemon.mjs", import.meta.url));
+
+  const logFile = await open("/tmp/schrun-daemon.log", "a");
+
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    stdio: ["ignore", logFile.fd, logFile.fd],
+  });
+
+  if (child.pid === undefined) {
+    await logFile.close();
+    throw new Error("Failed to start daemon");
+  }
+
+  child.on("error", (error) => {
+    console.error("Failed to start daemon:", error);
+  });
+
+  await writeFile(PID_FILE, String(child.pid));
+  child.unref();
+
+  await logFile.close();
+};

package/src/run/stopscheduler.ts

@@ -0,0 +1,29 @@
+import { readFile, unlink } from "node:fs/promises";
+import { PID_FILE } from "../constant/app.ts";
+import { consola } from "consola";
+
+export const stopschedule = async (): Promise<void> => {
+  let pid: number;
+
+  try {
+    pid = Number(await readFile(PID_FILE, "utf-8"));
+  } catch {
+    consola.warn("no look schedule pid file");
+    return;
+  }
+
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    consola.error("warning pid files");
+    return;
+  }
+
+  try {
+    process.kill(pid, "SIGINT");
+    consola.success("send stop to scheduler");
+  } catch (error) {
+    consola.error("failed stop to scheduler", error);
+    return;
+  }
+
+  await unlink(PID_FILE).catch(() => {});
+};

package/src/run/surface.ts

@@ -0,0 +1,27 @@
+import { consola } from "consola";
+import { readJSON } from "../readJSON.ts";
+import { spawn } from "node:child_process";
+
+export const runsurface = async (FileName: string): Promise<void> => {
+  const reads = await readJSON(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,11 @@
+import { z } from "zod";
+
+export const fileSchema = z.object({
+  id: z.number(),
+  description: z.string(),
+  cron: z.string(),
+  run: z.string(),
+  enabled: z.boolean(),
+});
+
+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
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    daemon: "src/run/daemon.ts",
+  },
+});