schrun 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,40 +1,19 @@
 #!/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 { readFile } from "node:fs/promises";
+import { open, readFile, unlink, writeFile } 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";
+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/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+/);
+	const [command, ...args] = (await readJSON(FileName)).run.split(/\s+/);
 	if (!command) {
 		consola.error("do not run commands");
 		return;
@@ -51,7 +30,7 @@ const runbackground = async (FileName) => {
 //#endregion
 //#region src/run/surface.ts
 const runsurface = async (FileName) => {
-	const [command, ...args] = (await readFiles(FileName)).run.split(/\s+/);
+	const [command, ...args] = (await readJSON(FileName)).run.split(/\s+/);
 	if (!command) {
 		consola.error("do not run commands");
 		return;
@@ -65,38 +44,115 @@ const runsurface = async (FileName) => {
 	});
 };
 //#endregion
-//#region src/index.ts
-const mainCommand = define({
-	name: CLI_COMMAND_NAME,
-	description: "agent and other task runner",
-	version: await version(),
+//#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: {
-		defaultInput: {
-			type: "positional",
+		start: {
+			type: "boolean",
 			required: false,
-			description: "Input value"
+			description: "Start scheduler"
 		},
-		background: {
-			type: "string",
+		stop: {
+			type: "boolean",
 			required: false,
-			description: "Run a task in the background"
+			description: "Stop scheduler"
 		}
 	},
-	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");
+	run: (ctx) => {
+		const { start, stop } = ctx.values;
+		if (start == true) startschedule();
+		if (stop == true) stopschedule();
 	}
-});
-await cli(process.argv.slice(2), mainCommand, {});
+};
+//#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,7 +1,7 @@
 {
   "name": "schrun",
   "module": "src/index.ts",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -23,6 +23,7 @@
     "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

@@ -3,3 +3,4 @@ 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

@@ -1,49 +1,5 @@
 #!/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";
+import { mainCommand } from "./commands/default";
 
-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, {});
+await mainCommand();

package/src/{read.ts → readJSON.ts}

@@ -4,7 +4,7 @@ import { CONFIG_DIR } from "./constant/app";
 import { fileSchema, type FileType } from "./type";
 import { consola } from "consola";
 
-export const readFiles = async (FileName: string): Promise<FileType> => {
+export const readJSON = async (FileName: string): Promise<FileType> => {
   const file = join(CONFIG_DIR, `${FileName}.json`);
   const reads = await readFile(file, "utf-8");
 

package/src/run/background.ts

@@ -1,9 +1,9 @@
 import { consola } from "consola";
-import { readFiles } from "../read.ts";
+import { readJSON } from "../readJSON.ts";
 import { spawn } from "node:child_process";
 
 export const runbackground = async (FileName: string): Promise<void> => {
-  const reads = await readFiles(FileName);
+  const reads = await readJSON(FileName);
   const commandsplit = reads.run.split(/\s+/);
 
   const [command, ...args] = commandsplit;

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

@@ -1,9 +1,9 @@
 import { consola } from "consola";
-import { readFiles } from "../read.ts";
+import { readJSON } from "../readJSON.ts";
 import { spawn } from "node:child_process";
 
 export const runsurface = async (FileName: string): Promise<void> => {
-  const reads = await readFiles(FileName);
+  const reads = await readJSON(FileName);
   const commandsplit = reads.run.split(/\s+/);
 
   const [command, ...args] = commandsplit;

package/src/type.ts

@@ -3,7 +3,9 @@ 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/tsdown.config.ts

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