me2lon 0.0.0-stage → 0.1.0

package/src/setup.ts

@@ -0,0 +1,95 @@
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { mkdir, realpath, stat } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { Me2lonAgentApi } from "./api.js";
+import { parseBaseUrl, projectConfigPath, readConfigFile, writeProjectConfig } from "./config.js";
+import { discoverWorkspace } from "./workspace-source.js";
+import { Me2lonClientError } from "./errors.js";
+import type { ConfigFileShape, SafeToolResult } from "./types.js";
+
+export type SetupOptions = {
+  directory?: string | undefined;
+  baseUrl?: string | undefined;
+  configPath?: string | undefined;
+  projectName?: string | undefined;
+  newCredential?: boolean | undefined;
+};
+
+function stringField(value: Record<string, unknown>, key: string): string {
+  const field = value[key];
+  if (typeof field !== "string" || field.length === 0 || field.length > 4096 || /[\r\n\0]/u.test(field)) {
+    throw new Me2lonClientError("ME2LON_API_RESPONSE_INVALID", "The authorization response is incomplete.");
+  }
+  return field;
+}
+
+export async function setupProject(options: SetupOptions, runtime: {
+  fetch?: typeof fetch;
+  wait?: (milliseconds: number) => Promise<unknown>;
+  notify: (value: SafeToolResult) => void;
+}): Promise<SafeToolResult> {
+  const workspace = await discoverWorkspace(options.directory ?? process.cwd());
+  const requestedPath = resolve(options.configPath ?? process.env.ME2LON_AGENT_CONFIG ?? projectConfigPath(workspace.root));
+  await mkdir(dirname(requestedPath), { recursive: true, mode: 0o700 });
+  const configPath = resolve(await realpath(dirname(requestedPath)), basename(requestedPath));
+  const relativeConfig = relative(workspace.root, configPath);
+  if (!relativeConfig.startsWith(`..${sep}`) && relativeConfig !== ".." && !isAbsolute(relativeConfig)) {
+    throw new Me2lonClientError("ME2LON_CONFIG_IN_SOURCE", "Keep the setup configuration outside the uploaded repository.");
+  }
+  let previous: ConfigFileShape = {};
+  try { await stat(configPath); previous = await readConfigFile(configPath); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+  if (previous.workspaceRoot && previous.workspaceRoot !== workspace.root) {
+    throw new Me2lonClientError("ME2LON_CONFIG_INVALID", "This configuration belongs to a different local project.");
+  }
+  const baseUrl = parseBaseUrl(options.baseUrl ?? process.env.ME2LON_AGENT_URL ?? previous.baseUrl ?? "https://me2lon.clarus.me");
+  const sameProject = previous.sourceFormat === "snapshot" && previous.baseUrl === baseUrl.origin;
+  const api = new Me2lonAgentApi(baseUrl, "", undefined, runtime.fetch);
+  const authorization = await api.request("/device-authorization", { method: "POST", body: {
+    projectName: options.projectName ?? basename(workspace.root).slice(0, 80),
+    ...(sameProject && previous.repositoryId ? { repositoryId: previous.repositoryId } : {}),
+    ...(sameProject && previous.credentialId && !options.newCredential ? { credentialId: previous.credentialId } : {}),
+  } });
+  const deviceCode = stringField(authorization, "deviceCode");
+  const userCode = stringField(authorization, "userCode");
+  const verificationUri = stringField(authorization, "verificationUri");
+  const verificationUrl = new URL(verificationUri);
+  parseBaseUrl(verificationUrl.origin);
+  if (verificationUrl.pathname !== "/agent-setup" || verificationUrl.searchParams.get("code") !== userCode ||
+    [...verificationUrl.searchParams.keys()].some((key) => key !== "code")) {
+    throw new Me2lonClientError("ME2LON_API_RESPONSE_INVALID", "The authorization link is invalid.");
+  }
+  runtime.notify({ status: "authorization_required", verificationUri, userCode,
+    message: "Open the link, sign in, and confirm that the displayed code matches. No token needs to be copied." });
+  const timeout = Math.min(600, typeof authorization.expiresIn === "number" ? authorization.expiresIn : 600) * 1000;
+  const deadline = Date.now() + timeout;
+  let interval = 5_000;
+  while (Date.now() < deadline) {
+    await (runtime.wait ?? delay)(interval);
+    const result = await api.request("/device-authorization/token", { method: "POST", body: { deviceCode } });
+    if (result.status === "pending") continue;
+    if (result.status === "slow_down") { interval = Math.min(30_000, interval + 5_000); continue; }
+    if (result.status === "denied" || result.status === "expired") {
+      throw new Me2lonClientError("ME2LON_AUTHORIZATION_INCOMPLETE", `Authorization ${result.status}; run setup again when ready.`);
+    }
+    if (result.status !== "authorized" || typeof result.credential !== "object" || result.credential === null) {
+      throw new Me2lonClientError("ME2LON_API_RESPONSE_INVALID", "Unknown authorization response.");
+    }
+    const token = stringField(result, "token");
+    if (!/^m2lon_agent_v1_[A-Za-z0-9_-]{43}$/u.test(token)) throw new Me2lonClientError("ME2LON_API_RESPONSE_INVALID", "Invalid authorization credential.");
+    const credentialId = stringField(result.credential as Record<string, unknown>, "id");
+    const repositoryId = stringField(result, "repositoryId");
+    const keepState = sameProject && previous.credentialId === credentialId && previous.repositoryId === repositoryId;
+    await writeProjectConfig(configPath, {
+      baseUrl: baseUrl.origin, token, workspaceRoot: workspace.root, repositoryId,
+      credentialId, sourceFormat: "snapshot",
+      ...(keepState && previous.workspaceId ? { workspaceId: previous.workspaceId } : {}),
+      ...(keepState && previous.previousRevisionId ? { previousRevisionId: previous.previousRevisionId } : {}),
+    });
+    return {
+      status: "ready", repositoryId, configPath,
+      nextCommand: "me2lon analyze --wait",
+    };
+  }
+  throw new Me2lonClientError("ME2LON_AUTHORIZATION_INCOMPLETE", "Authorization expired; run setup again.");
+}

package/src/skill.ts

@@ -0,0 +1,22 @@
+import { Me2lonClientError } from "./errors.js";
+import { mkdir, readFile, lstat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+export async function installSkill(agent = 'generic', destination?: string, force = false, home = homedir()): Promise<string> {
+  if (!['generic', 'codex', 'claude'].includes(agent)) throw new Me2lonClientError("ME2LON_CLIENT_INPUT", 'Use --agent generic, codex, or claude, or --path DIRECTORY.');
+  const target = destination ? resolve(destination) : join(home, agent === 'claude' ? '.claude' : '.agents', 'skills', 'me2lon');
+  const files = await Promise.all(['SKILL.md', 'LICENSE'].map(async name => ({ name, text: await readFile(new URL(`../skill/${name}`, import.meta.url), 'utf8') })));
+  // Check every destination before changing any file. Never follow destination file symlinks.
+  for (const { name, text } of files) {
+    const path = join(target, name);
+    try {
+      const stat = await lstat(path);
+      if (!stat.isFile() || stat.isSymbolicLink()) throw new Me2lonClientError("ME2LON_CLIENT_INPUT", `Refusing non-regular skill file: ${path}`);
+      if (!force && await readFile(path, 'utf8') !== text) throw new Me2lonClientError("ME2LON_CLIENT_INPUT", `Existing skill differs: ${path}. Use --force to replace it.`);
+    } catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  }
+  await mkdir(target, { recursive: true });
+  for (const { name, text } of files) await writeFile(join(target, name), text);
+  return target;
+}

package/src/types.ts

@@ -0,0 +1,85 @@
+export const SOURCE_SCHEMA_VERSION = "me2lon-agent-source/v1" as const;
+export const SNAPSHOT_SCHEMA_VERSION = "me2lon-agent-source/v2" as const;
+
+export const LOCAL_SOURCE_LIMITS = Object.freeze({
+  maxChanges: 2_000,
+  maxFileBytes: 1024 * 1024,
+  maxTotalBytes: 8 * 1024 * 1024,
+});
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue =
+  | JsonPrimitive
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export type ReplaceChange = {
+  operation: "replace";
+  path: string;
+  content: string;
+}
+
+export type DeleteChange = {
+  operation: "delete";
+  path: string;
+}
+
+export type SourceChange = ReplaceChange | DeleteChange;
+
+export type SourceLimits = {
+  maxChanges: number;
+  maxFileBytes: number;
+  maxTotalBytes: number;
+}
+
+export type WorkspaceSource = {
+  schemaVersion: typeof SOURCE_SCHEMA_VERSION;
+  baseCommitSha: string;
+  changes: SourceChange[];
+  digest: string;
+  replacementCount: number;
+  deletionCount: number;
+  totalReplacementBytes: number;
+}
+
+export type BoundWorkspace = {
+  root: string;
+  repositoryId: string;
+  baseCommitSha: string;
+}
+
+export type AgentRuntimeConfig = {
+  baseUrl: URL;
+  token: string;
+  workspace: BoundWorkspace;
+  configPath?: string;
+  sourceFormat?: "snapshot";
+  credentialId?: string;
+  workspaceId?: string;
+  previousRevisionId?: string;
+}
+
+export type ConfigFileShape = {
+  baseUrl?: string;
+  token?: string;
+  workspaceRoot?: string;
+  repositoryId?: string;
+  baseCommitSha?: string;
+  sourceFormat?: "snapshot";
+  credentialId?: string;
+  workspaceId?: string;
+  previousRevisionId?: string;
+}
+
+export type WorkspaceSnapshot = {
+  schemaVersion: typeof SNAPSHOT_SCHEMA_VERSION;
+  baseCommitSha: string;
+  branchLabel: string | null;
+  files: { path: string; content: string }[];
+  digest: string;
+  totalReplacementBytes: number;
+};
+
+export type SafeToolResult = {
+  [key: string]: JsonValue;
+}