agent-sin 0.1.0

package/dist/core/scheduler.js

@@ -0,0 +1,155 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { l } from "./i18n.js";
+export async function loadSchedules(workspace) {
+    const file = schedulesFile(workspace);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        try {
+            raw = await readFile(legacySchedulesFile(workspace), "utf8");
+        }
+        catch {
+            return [];
+        }
+    }
+    const parsed = YAML.parse(raw);
+    const list = parsed && Array.isArray(parsed.schedules) ? parsed.schedules : [];
+    const seen = new Set();
+    const entries = [];
+    for (const item of list) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const record = item;
+        const id = String(record.id || "").trim();
+        if (!id) {
+            throw new Error(l("Invalid schedule: missing id", "スケジュールが不正です: id がありません"));
+        }
+        if (seen.has(id)) {
+            throw new Error(l(`Duplicate schedule id: ${id}`, `スケジュール id が重複しています: ${id}`));
+        }
+        seen.add(id);
+        const cronText = String(record.cron || "").trim();
+        if (!cronText) {
+            throw new Error(l(`Invalid schedule '${id}': missing cron`, `スケジュール '${id}' が不正です: cron がありません`));
+        }
+        const skill = String(record.skill || "").trim();
+        if (!skill) {
+            throw new Error(l(`Invalid schedule '${id}': missing skill`, `スケジュール '${id}' が不正です: skill がありません`));
+        }
+        const expression = parseCron(cronText);
+        const enabled = record.enabled === undefined ? true : Boolean(record.enabled);
+        const args = isPlainObject(record.args) ? record.args : {};
+        const approve = Boolean(record.approve);
+        const description = record.description ? String(record.description) : undefined;
+        entries.push({ id, cron: cronText, skill, enabled, args, approve, description, expression });
+    }
+    return entries;
+}
+export function schedulesFile(workspace) {
+    return path.join(workspace, "schedules.yaml");
+}
+export function legacySchedulesFile(workspace) {
+    return path.join(workspace, "schedules", "schedules.yaml");
+}
+export function parseCron(raw) {
+    const fields = raw.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        throw new Error(l(`Cron must have 5 fields ("min hour dom month dow"): "${raw}"`, `Cron は5フィールド ("min hour dom month dow") で指定してください: "${raw}"`));
+    }
+    return {
+        raw,
+        minute: parseField(fields[0], 0, 59, "minute"),
+        hour: parseField(fields[1], 0, 23, "hour"),
+        dayOfMonth: parseField(fields[2], 1, 31, "day-of-month"),
+        month: parseField(fields[3], 1, 12, "month"),
+        dayOfWeek: parseField(fields[4], 0, 6, "day-of-week"),
+    };
+}
+function parseField(field, min, max, label) {
+    const values = new Set();
+    let isWildcard = field === "*" || field === "*/1";
+    for (const part of field.split(",")) {
+        const segment = part.trim();
+        if (!segment) {
+            throw new Error(l(`Empty segment in ${label} field: "${field}"`, `${label} フィールドに空のセグメントがあります: "${field}"`));
+        }
+        let step = 1;
+        let body = segment;
+        const slashIndex = body.indexOf("/");
+        if (slashIndex >= 0) {
+            const stepRaw = body.slice(slashIndex + 1);
+            const stepValue = Number.parseInt(stepRaw, 10);
+            if (!Number.isFinite(stepValue) || stepValue <= 0) {
+                throw new Error(l(`Invalid step "${stepRaw}" in ${label} field: "${field}"`, `${label} フィールドの step が不正です: "${stepRaw}" ("${field}")`));
+            }
+            step = stepValue;
+            body = body.slice(0, slashIndex);
+            isWildcard = isWildcard && step === 1;
+        }
+        let from = min;
+        let to = max;
+        if (body !== "" && body !== "*") {
+            const dashIndex = body.indexOf("-");
+            if (dashIndex >= 0) {
+                from = Number.parseInt(body.slice(0, dashIndex), 10);
+                to = Number.parseInt(body.slice(dashIndex + 1), 10);
+                isWildcard = false;
+            }
+            else {
+                from = Number.parseInt(body, 10);
+                to = from;
+                isWildcard = false;
+            }
+            if (!Number.isFinite(from) || !Number.isFinite(to)) {
+                throw new Error(l(`Invalid value "${body}" in ${label} field: "${field}"`, `${label} フィールドの値が不正です: "${body}" ("${field}")`));
+            }
+            if (from < min || to > max || from > to) {
+                throw new Error(l(`${label} value out of range (${from}-${to}); allowed ${min}-${max} for "${field}"`, `${label} の値が範囲外です (${from}-${to}); 使用可能範囲 ${min}-${max} ("${field}")`));
+            }
+        }
+        for (let value = from; value <= to; value += step) {
+            values.add(value);
+        }
+    }
+    return { values, isWildcard };
+}
+export function matchesCron(expression, date) {
+    if (!expression.minute.values.has(date.getMinutes())) {
+        return false;
+    }
+    if (!expression.hour.values.has(date.getHours())) {
+        return false;
+    }
+    if (!expression.month.values.has(date.getMonth() + 1)) {
+        return false;
+    }
+    const dom = expression.dayOfMonth;
+    const dow = expression.dayOfWeek;
+    const domMatch = dom.values.has(date.getDate());
+    const dowMatch = dow.values.has(date.getDay());
+    // POSIX cron: when both dom and dow are restricted, OR them; otherwise AND.
+    if (!dom.isWildcard && !dow.isWildcard) {
+        return domMatch || dowMatch;
+    }
+    return domMatch && dowMatch;
+}
+export function nextRunAfter(expression, from, lookaheadMinutes = 7 * 24 * 60) {
+    const cursor = new Date(from.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1);
+    for (let i = 0; i < lookaheadMinutes; i += 1) {
+        if (matchesCron(expression, cursor)) {
+            return new Date(cursor.getTime());
+        }
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+    return null;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/core/secrets.d.ts

@@ -0,0 +1,31 @@
+export interface DotenvLoadResult {
+    loaded: boolean;
+    path: string;
+    vars_set: number;
+    permission_warning?: string;
+}
+export declare function dotenvPath(workspace?: string): Promise<string>;
+export declare function readDotenvKeys(workspace?: string): Promise<Set<string>>;
+export declare function loadDotenv(workspace?: string): Promise<DotenvLoadResult>;
+export declare function upsertDotenv(workspace: string, entries: Array<{
+    key: string;
+    value: string;
+}>): Promise<{
+    path: string;
+}>;
+export interface ApiKeySource {
+    provider: string;
+    envVar: string;
+}
+export interface ApiKeyResolution {
+    provider: string;
+    keys: string[];
+    sources: ApiKeySource[];
+}
+export declare function getApiKeyResolution(provider: string, fallbackProviders?: string[]): ApiKeyResolution;
+export declare function getApiKeys(provider: string, fallbackProviders?: string[]): string[];
+export declare function maskKey(key: string): string;
+export declare function ensureDotenvSkeleton(workspace: string): Promise<{
+    created: boolean;
+    path: string;
+}>;

package/dist/core/secrets.js

@@ -0,0 +1,214 @@
+import { readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultWorkspace } from "./config.js";
+export async function dotenvPath(workspace = defaultWorkspace()) {
+    return path.join(workspace, ".env");
+}
+// .env に書かれているキー名だけを返す (process.env には影響しない)。
+// setup の検出表示で「シェルから漏れているキー」を「.env 由来」と誤認しないために使う。
+export async function readDotenvKeys(workspace = defaultWorkspace()) {
+    const file = path.join(workspace, ".env");
+    const keys = new Set();
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return keys;
+    }
+    for (const line of raw.split(/\r?\n/)) {
+        const parsed = parseDotenvLine(line);
+        if (parsed && parsed.value.length > 0) {
+            keys.add(parsed.key);
+        }
+    }
+    return keys;
+}
+export async function loadDotenv(workspace = defaultWorkspace()) {
+    const file = await dotenvPath(workspace);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch {
+        return { loaded: false, path: file, vars_set: 0 };
+    }
+    let permissionWarning;
+    try {
+        const info = await stat(file);
+        const mode = info.mode & 0o777;
+        if ((mode & 0o077) !== 0) {
+            permissionWarning = `permissions ${mode.toString(8).padStart(3, "0")} on ${file} are too open; recommend: chmod 600 ${file}`;
+        }
+    }
+    catch {
+        // Ignore stat failures; the file was readable above.
+    }
+    let varsSet = 0;
+    for (const line of raw.split(/\r?\n/)) {
+        const parsed = parseDotenvLine(line);
+        if (!parsed) {
+            continue;
+        }
+        if (process.env[parsed.key] === undefined) {
+            process.env[parsed.key] = parsed.value;
+            varsSet += 1;
+        }
+    }
+    return { loaded: true, path: file, vars_set: varsSet, permission_warning: permissionWarning };
+}
+function parseDotenvLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+        return null;
+    }
+    const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) {
+        return null;
+    }
+    let value = match[2].trim();
+    if (value.length >= 2) {
+        const first = value.charAt(0);
+        const last = value.charAt(value.length - 1);
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            value = value.slice(1, -1);
+            return { key: match[1], value };
+        }
+    }
+    // Strip trailing inline comment ` # ...` (only when preceded by whitespace).
+    const commentIndex = findInlineCommentIndex(value);
+    if (commentIndex >= 0) {
+        value = value.slice(0, commentIndex).trim();
+    }
+    return { key: match[1], value };
+}
+function findInlineCommentIndex(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        if (value.charAt(i) === "#" && (i === 0 || /\s/.test(value.charAt(i - 1)))) {
+            return i;
+        }
+    }
+    return -1;
+}
+export async function upsertDotenv(workspace, entries) {
+    const file = path.join(workspace, ".env");
+    let existing = "";
+    try {
+        existing = await readFile(file, "utf8");
+    }
+    catch {
+        existing = "";
+    }
+    const lines = existing.split(/\r?\n/);
+    const updated = new Set();
+    for (const { key, value } of entries) {
+        const formatted = `${key}=${formatDotenvValue(value)}`;
+        let replaced = false;
+        for (let i = 0; i < lines.length; i += 1) {
+            const trimmed = lines[i].trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+            if (match && match[1] === key) {
+                lines[i] = formatted;
+                replaced = true;
+                break;
+            }
+        }
+        if (!replaced) {
+            lines.push(formatted);
+        }
+        updated.add(key);
+        process.env[key] = value;
+    }
+    let next = lines.join("\n");
+    if (!next.endsWith("\n"))
+        next = `${next}\n`;
+    await writeFile(file, next, { mode: 0o600 });
+    return { path: file };
+}
+function formatDotenvValue(value) {
+    if (/[\s"'#]/.test(value) || value === "") {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+const NUMBERED_KEY_LIMIT = 32;
+export function getApiKeyResolution(provider, fallbackProviders = []) {
+    const keys = [];
+    const seen = new Set();
+    const sources = [];
+    for (const candidate of [provider, ...fallbackProviders]) {
+        const upper = candidate.toUpperCase();
+        pushKey(keys, seen, sources, candidate, `AGENT_SIN_LIVE_${upper}_KEY`, process.env[`AGENT_SIN_LIVE_${upper}_KEY`]);
+        const list = process.env[`${upper}_API_KEYS`];
+        if (list) {
+            for (const item of list.split(/[,;]/)) {
+                pushKey(keys, seen, sources, candidate, `${upper}_API_KEYS`, item);
+            }
+        }
+        pushKey(keys, seen, sources, candidate, `${upper}_API_KEY`, process.env[`${upper}_API_KEY`]);
+        for (let i = 1; i <= NUMBERED_KEY_LIMIT; i += 1) {
+            pushKey(keys, seen, sources, candidate, `${upper}_API_KEY_${i}`, process.env[`${upper}_API_KEY_${i}`]);
+        }
+    }
+    return { provider, keys, sources };
+}
+export function getApiKeys(provider, fallbackProviders = []) {
+    return getApiKeyResolution(provider, fallbackProviders).keys;
+}
+function pushKey(keys, seen, sources, provider, envVar, value) {
+    if (!value) {
+        return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) {
+        return;
+    }
+    seen.add(trimmed);
+    keys.push(trimmed);
+    sources.push({ provider, envVar });
+}
+export function maskKey(key) {
+    if (!key) {
+        return "<empty>";
+    }
+    if (key.length <= 8) {
+        return `${key.slice(0, 2)}...${key.slice(-2)}`;
+    }
+    return `${key.slice(0, 4)}...${key.slice(-4)} (len=${key.length})`;
+}
+const DOTENV_TEMPLATE = `# Agent-Sin secrets file
+# Recommend: chmod 600 ~/.agent-sin/.env
+# Lines starting with # are ignored.
+#
+# Uncomment the line for the provider you want to use and paste your key.
+# After editing, run \`agent-sin setup\` again — the new keys will be detected.
+
+# --- OpenAI (https://platform.openai.com/api-keys) ---
+# OPENAI_API_KEY=sk-...
+
+# --- Gemini / Google AI (https://aistudio.google.com/app/apikey) ---
+# GEMINI_API_KEY=AIza...
+
+# --- Anthropic API (https://console.anthropic.com/settings/keys) ---
+# ANTHROPIC_API_KEY=sk-ant-...
+
+# --- Ollama (local) ---
+# No API key needed. Run \`ollama serve\` and \`ollama pull <model>\` first.
+# Uncomment only if Ollama is not on the default localhost:11434.
+# OLLAMA_HOST=http://localhost:11434
+`;
+export async function ensureDotenvSkeleton(workspace) {
+    const file = path.join(workspace, ".env");
+    try {
+        await stat(file);
+        return { created: false, path: file };
+    }
+    catch {
+        // File does not exist; create skeleton.
+    }
+    await writeFile(file, DOTENV_TEMPLATE, { mode: 0o600 });
+    return { created: true, path: file };
+}

package/dist/core/service.d.ts

@@ -0,0 +1,35 @@
+import type { AppConfig } from "./config.js";
+export declare const SERVICE_LABEL_DARWIN = "com.agent-sin.gateway";
+export declare const SERVICE_TASK_NAME_WINDOWS = "Agent-Sin Gateway";
+export interface ServiceStatusInfo {
+    installed: boolean;
+    manifestPath: string;
+    manifestKind: "plist" | "schtasks" | "none";
+}
+export interface ServiceProvider {
+    readonly platformId: "darwin" | "windows" | "unsupported";
+    readonly label: string;
+    readonly supported: boolean;
+    install(config: AppConfig, options?: {
+        noStart?: boolean;
+    }): Promise<void>;
+    start(config: AppConfig): Promise<void>;
+    stop(options?: {
+        quiet?: boolean;
+        wait?: boolean;
+    }): Promise<void>;
+    manifestText(config: AppConfig): string;
+    status(config: AppConfig): Promise<ServiceStatusInfo>;
+    notSupportedReason(): string;
+}
+export declare function renderServiceManifestForPlatform(config: AppConfig, platform?: NodeJS.Platform): {
+    label: string;
+    manifestKind: "plist" | "schtasks";
+    text: string;
+};
+export declare function getServiceProvider(): ServiceProvider;
+export declare function serviceLabel(): string;
+export declare function findAgentSinServiceProcesses(): Promise<string[]>;
+export declare function isServiceCommandLine(line: string): boolean;
+export declare function isSchedulerCommandLine(line: string): boolean;
+export declare function isSchedulerProcessRunning(): Promise<boolean>;