@artil-ai/server 0.2.1 → 0.2.3

package/README.md

@@ -31,23 +31,28 @@ The first run sets everything up. Files need an S3-compatible bucket, and
 reaching the server from outside needs Tailscale. Both can wait for
 `artil-server setup`.
 
-**2. Sign a client in**
+**2. Sign in the accounts the setup made**
 
 ```bash
-artil auth login --base-url http://localhost:4747
+artil auth login --base-url http://localhost:4747 --account claude
+artil auth login --base-url http://localhost:4747 --account codex
 ```
 
-The CLI remembers the server from here on.
+`--base-url` needs artil 0.42.0 or later; `artil update` gets it. The CLI
+remembers the server from here on, and works as `claude`, the first account,
+unless you [choose another](https://docs.artil.ai/accounts).
 
-**3. Message another agent**
+**3. Connect a client to each account**
+
+Start Claude Code and Codex
+[as Artil Connect describes](https://docs.artil.ai/connect), each as its own
+account. A message reaches an account only while its client listens.
+
+**4. Message another agent**
 
 ```bash
 artil url send codex "Review the release branch"
 ```
 
-That is `claude` writing to `codex`, the other account the setup made.
-Everything else works [as with Artil Cloud](https://docs.artil.ai/connect).
-
-## TODO
-
-- [ ] Message URL as a regular channel, not a transport built into the server
+That is `claude` writing to `codex`. Everything else works as with Artil
+Cloud.

package/bin/main.js

@@ -22326,7 +22326,7 @@ var channel = {
   create: ({ webhookUrl, secret, fetch: fetch2 }) => new TelegramChannel(createBotApi({ webhook: webhookUrl ? { url: webhookUrl, secret } : undefined, fetch: fetch2 }))
 };
 // package.json
-var version2 = "0.2.1";
+var version2 = "0.2.3";
 
 // src/app/cli.ts
 import { parseArgs } from "util";
@@ -52142,7 +52142,9 @@ async function startServer({
   store = config2.s3 ? createS3Store(config2.s3) : undefined,
   fetch: fetch2
 }) {
+  await using startup = new AsyncDisposableStack;
   const database = openDatabase({ path: databasePath, migrationsFolder, secret: config2.secret });
+  startup.defer(() => database.close());
   let handleRequest = startingResponse;
   const server = Bun.serve({
     hostname: "127.0.0.1",
@@ -52150,12 +52152,11 @@ async function startServer({
     fetch: (request) => handleRequest(request),
     idleTimeout: 60
   });
+  startup.defer(() => server.stop(true));
   const port = server.port ?? config2.port;
-  const publicUrl = config2.public && tailscale ? await tailscale.open(port).catch(async (cause) => {
-    await server.stop(true);
-    database.close();
-    throw cause;
-  }) : undefined;
+  const publicUrl = config2.public && tailscale ? await tailscale.open(port) : undefined;
+  if (publicUrl)
+    startup.defer(() => tailscale?.close());
   const baseUrl = publicUrl ?? `http://localhost:${port}`;
   const channels = createChannels({
     definitions,
@@ -52190,6 +52191,10 @@ async function startServer({
     for (const channelReceivers of receivers)
       channelReceivers.sync();
   }
+  startup.defer(() => {
+    for (const channelReceivers of receivers)
+      channelReceivers.stop();
+  });
   syncReceivers();
   let dataVersion = database.dataVersion();
   const databaseWatcher = setInterval(() => {
@@ -52199,28 +52204,193 @@ async function startServer({
       syncReceivers();
     }
   }, 2 * second);
+  startup.defer(() => clearInterval(databaseWatcher));
   function removeExpiredFiles() {
     services.files.removeExpired().catch((cause) => log2(`Could not remove expired files: ${messageOf(cause, String(cause))}`));
   }
   removeExpiredFiles();
   const expiredFilesTimer = setInterval(removeExpiredFiles, hour);
+  startup.defer(() => clearInterval(expiredFilesTimer));
+  const resources = startup.move();
   return {
     baseUrl,
     port,
     services,
-    async stop() {
-      clearInterval(databaseWatcher);
-      clearInterval(expiredFilesTimer);
-      for (const channelReceivers of receivers)
-        channelReceivers.stop();
-      await server.stop(true);
-      if (publicUrl)
-        await tailscale?.close();
-      database.close();
-    }
+    stop: () => resources.disposeAsync()
   };
 }
 
+// src/app/cli.ts
+var usage = `artil-server: a self-hosted Artil Server
+
+Usage:
+  artil-server                                             Start the server, setting it up first if it is new
+  artil-server setup                                       Set up the accounts, channels, files and who reaches the server
+  artil-server account create <name>                       Create an agent account
+  artil-server account list                                List the accounts
+  artil-server account remove <name>                       Remove an account with its messages
+  artil-server account token <name>                        Make a token, for a computer without a browser
+  artil-server account revoke <name>                       Sign the account out of every client
+  artil-server <channel> connect <account> <credentials>   Connect an address of a channel to an account, with what the channel asks for
+  artil-server <channel> disconnect <account>              Disconnect the account's address of the channel
+  artil-server access add <account> <channel> <sender>     Let someone wake the agent on the channel
+  artil-server access remove <account> <channel> <sender>  Take them off the list
+  artil-server access set <account> <channel> <who>        Choose who wakes the agent on the channel: anyone, team or list
+  artil-server password                                    Set the password the sign-in page asks for
+
+Options:
+  --public          Open the server to the internet through Tailscale Funnel
+  --local           Keep the server on this computer
+  -h, --help        Show this help
+  -v, --version     Show the version`;
+function usageError(message) {
+  return new AppError({ code: "invalid_input", message: `${message}
+
+${usage}` });
+}
+async function serve({ paths, config: config2, environment }) {
+  const { migrationsFolder, tailscale, out } = environment;
+  if (config2.public && !tailscale) {
+    throw new AppError({
+      code: "unavailable",
+      message: "Public mode needs Tailscale: install it from https://tailscale.com/download, or start with --local"
+    });
+  }
+  if (config2.public && config2.password === null) {
+    throw new AppError({
+      code: "invalid_input",
+      message: "Public mode needs a password for the sign-in page: set one with artil-server password"
+    });
+  }
+  const server = await startServer({
+    config: config2,
+    databasePath: paths.database,
+    migrationsFolder,
+    tailscale,
+    channels: await loadChannels({
+      specifiers: config2.channels,
+      dataDir: paths.dataDir,
+      builtInChannels: environment.builtInChannels
+    }),
+    password: async () => (await readConfig(paths))?.password ?? null,
+    log: out
+  });
+  out(`Artil Server is at ${server.baseUrl}${config2.public ? " (public, through Tailscale Funnel)" : ""}.`);
+  out(`Sign an agent in with: ${loginCommand(server.baseUrl)}`);
+  out(`MCP clients connect to ${server.baseUrl}/mcp`);
+  await environment.waitForStop();
+  out("Stopping");
+  await server.stop();
+}
+async function setPassword({ paths, config: config2, out }) {
+  const newPassword = await password({
+    message: "A password the sign-in page asks for",
+    validate: validatePassword
+  });
+  if (isCancel(newPassword))
+    return;
+  await writeConfig(paths, { ...config2, password: await hashPassword(newPassword) });
+  out("The sign-in page asks for it from now on.");
+}
+async function runCli(environment) {
+  const { values, positionals } = parseArgs({
+    args: environment.argv,
+    allowPositionals: true,
+    options: {
+      public: { type: "boolean" },
+      local: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  if (values.help)
+    return environment.out(usage);
+  if (values.version)
+    return environment.out(environment.version);
+  const paths = pathsIn(environment.dataDir);
+  const savedConfig = await readConfig(paths);
+  async function applyFlags(config3) {
+    const changed = {
+      ...config3,
+      ...values.public && { public: true },
+      ...values.local && { public: false }
+    };
+    if (changed.public !== config3.public)
+      await writeConfig(paths, changed);
+    return changed;
+  }
+  const [command = "", subcommand = "", ...args] = positionals;
+  const { migrationsFolder, tailscale, artil, runSetup, out, interactive, builtInChannels } = environment;
+  const builtInKinds = builtInChannels.map(({ kind }) => kind);
+  async function hasAgents(config3) {
+    const context2 = await openCommandContext({
+      paths,
+      config: config3,
+      builtInChannels,
+      migrationsFolder,
+      tailscale,
+      out
+    });
+    try {
+      return context2.agents.list().length > 0;
+    } finally {
+      context2.close();
+    }
+  }
+  if (command === "" || command === "start") {
+    const config3 = interactive && (!savedConfig || !await hasAgents(savedConfig)) ? await runSetup({
+      paths,
+      config: savedConfig,
+      builtInChannels,
+      artil,
+      migrationsFolder,
+      tailscale,
+      out
+    }) : savedConfig ?? newConfig({ channels: builtInKinds });
+    if (!savedConfig && !interactive)
+      await writeConfig(paths, config3);
+    return serve({ paths, config: await applyFlags(config3), environment });
+  }
+  if (command === "setup") {
+    await runSetup({
+      paths,
+      config: savedConfig,
+      builtInChannels,
+      artil,
+      migrationsFolder,
+      tailscale,
+      out
+    });
+    return;
+  }
+  const config2 = savedConfig ?? newConfig({ channels: builtInKinds });
+  if (!savedConfig)
+    await writeConfig(paths, config2);
+  if (command === "password")
+    return setPassword({ paths, config: config2, out });
+  const context = await openCommandContext({
+    paths,
+    config: config2,
+    builtInChannels,
+    migrationsFolder,
+    tailscale,
+    out
+  });
+  try {
+    const run2 = new Map([...createAgentCommands(context), ...createAccessCommands(context)]).get(`${command} ${subcommand}`) ?? createAddressCommands(context).get(subcommand)?.(command);
+    if (!run2) {
+      throw usageError(`There is no command ${[command, subcommand].filter(Boolean).join(" ")}`);
+    }
+    if (args.length !== run2.takes.length) {
+      const expected = run2.takes.map((name) => `<${name}>`).join(" ") || "no arguments";
+      throw usageError(`This command takes ${expected}`);
+    }
+    await run2.run(Object.fromEntries(run2.takes.map((name, index2) => [name, args[index2] ?? ""])));
+  } finally {
+    context.close();
+  }
+}
+
 // src/app/setup.ts
 class SetupStopped extends Error {
   name = "SetupStopped";
@@ -52456,165 +52626,6 @@ async function runSetup({
   }
 }
 
-// src/app/cli.ts
-var usage = `artil-server: a self-hosted Artil Server
-
-Usage:
-  artil-server                                             Start the server, setting it up first if it is new
-  artil-server setup                                       Set up the accounts, channels, files and who reaches the server
-  artil-server account create <name>                       Create an agent account
-  artil-server account list                                List the accounts
-  artil-server account remove <name>                       Remove an account with its messages
-  artil-server account token <name>                        Make a token, for a computer without a browser
-  artil-server account revoke <name>                       Sign the account out of every client
-  artil-server <channel> connect <account> <credentials>   Connect an address of a channel to an account, with what the channel asks for
-  artil-server <channel> disconnect <account>              Disconnect the account's address of the channel
-  artil-server access add <account> <channel> <sender>     Let someone wake the agent on the channel
-  artil-server access remove <account> <channel> <sender>  Take them off the list
-  artil-server access set <account> <channel> <who>        Choose who wakes the agent on the channel: anyone, team or list
-  artil-server password                                    Set the password the sign-in page asks for
-
-Options:
-  --public          Open the server to the internet through Tailscale Funnel
-  --local           Keep the server on this computer
-  -h, --help        Show this help
-  -v, --version     Show the version`;
-function usageError(message) {
-  return new AppError({ code: "invalid_input", message: `${message}
-
-${usage}` });
-}
-async function serve({ paths, config: config2, environment }) {
-  const { migrationsFolder, tailscale, out } = environment;
-  if (config2.public && !tailscale) {
-    throw new AppError({
-      code: "unavailable",
-      message: "Public mode needs Tailscale: install it from https://tailscale.com/download, or start with --local"
-    });
-  }
-  if (config2.public && config2.password === null) {
-    throw new AppError({
-      code: "invalid_input",
-      message: "Public mode needs a password for the sign-in page: set one with artil-server password"
-    });
-  }
-  const server = await startServer({
-    config: config2,
-    databasePath: paths.database,
-    migrationsFolder,
-    tailscale,
-    channels: await loadChannels({
-      specifiers: config2.channels,
-      dataDir: paths.dataDir,
-      builtInChannels: environment.builtInChannels
-    }),
-    password: async () => (await readConfig(paths))?.password ?? null,
-    log: out
-  });
-  out(`Artil Server is at ${server.baseUrl}${config2.public ? " (public, through Tailscale Funnel)" : ""}.`);
-  out(`Sign an agent in with: ${loginCommand(server.baseUrl)}`);
-  out(`MCP clients connect to ${server.baseUrl}/mcp`);
-  const { promise: promise3, resolve } = Promise.withResolvers();
-  process.once("SIGINT", resolve);
-  process.once("SIGTERM", resolve);
-  await promise3;
-  out("Stopping");
-  await server.stop();
-}
-async function setPassword({ paths, config: config2, out }) {
-  const newPassword = await password({
-    message: "A password the sign-in page asks for",
-    validate: validatePassword
-  });
-  if (isCancel(newPassword))
-    return;
-  await writeConfig(paths, { ...config2, password: await hashPassword(newPassword) });
-  out("The sign-in page asks for it from now on.");
-}
-async function runCli(environment) {
-  const { values, positionals } = parseArgs({
-    args: environment.argv,
-    allowPositionals: true,
-    options: {
-      public: { type: "boolean" },
-      local: { type: "boolean" },
-      help: { type: "boolean", short: "h" },
-      version: { type: "boolean", short: "v" }
-    }
-  });
-  if (values.help)
-    return environment.out(usage);
-  if (values.version)
-    return environment.out(environment.version);
-  const paths = pathsIn(environment.dataDir);
-  const savedConfig = await readConfig(paths);
-  async function applyFlags(config3) {
-    const changed = {
-      ...config3,
-      ...values.public && { public: true },
-      ...values.local && { public: false }
-    };
-    if (changed.public !== config3.public)
-      await writeConfig(paths, changed);
-    return changed;
-  }
-  const [command = "", subcommand = "", ...args] = positionals;
-  const { migrationsFolder, tailscale, artil, out, interactive, builtInChannels } = environment;
-  const builtInKinds = builtInChannels.map(({ kind }) => kind);
-  if (command === "" || command === "start") {
-    const config3 = savedConfig ?? (interactive ? await runSetup({
-      paths,
-      config: undefined,
-      builtInChannels,
-      artil,
-      migrationsFolder,
-      tailscale,
-      out
-    }) : newConfig({ channels: builtInKinds }));
-    if (!savedConfig && !interactive)
-      await writeConfig(paths, config3);
-    return serve({ paths, config: await applyFlags(config3), environment });
-  }
-  if (command === "setup") {
-    await runSetup({
-      paths,
-      config: savedConfig,
-      builtInChannels,
-      artil,
-      migrationsFolder,
-      tailscale,
-      out
-    });
-    return;
-  }
-  const config2 = savedConfig ?? newConfig({ channels: builtInKinds });
-  if (!savedConfig)
-    await writeConfig(paths, config2);
-  if (command === "password")
-    return setPassword({ paths, config: config2, out });
-  const context = await openCommandContext({
-    paths,
-    config: config2,
-    builtInChannels,
-    migrationsFolder,
-    tailscale,
-    out
-  });
-  try {
-    const run2 = new Map([...createAgentCommands(context), ...createAccessCommands(context)]).get(`${command} ${subcommand}`) ?? createAddressCommands(context).get(subcommand)?.(command);
-    if (!run2) {
-      throw usageError(`There is no command ${[command, subcommand].filter(Boolean).join(" ")}`);
-    }
-    if (args.length !== run2.takes.length) {
-      const expected = run2.takes.map((name) => `<${name}>`).join(" ") || "no arguments";
-      throw usageError(`This command takes ${expected}`);
-    }
-    await run2.run(Object.fromEntries(run2.takes.map((name, index2) => [name, args[index2] ?? ""])));
-  } finally {
-    context.close();
-  }
-}
-
 // src/platform/tailscale.ts
 import { existsSync } from "fs";
 var statusSchema = exports_external2.object({
@@ -52694,6 +52705,12 @@ function runWith(binary) {
 var migrationsFolder = fileURLToPath(new URL("../migrations", import.meta.url));
 process.umask(63);
 var binary = findTailscale(process.platform);
+function waitForStop() {
+  const { promise: promise3, resolve } = Promise.withResolvers();
+  process.once("SIGINT", resolve);
+  process.once("SIGTERM", resolve);
+  return promise3;
+}
 try {
   await runCli({
     argv: process.argv.slice(2),
@@ -52704,6 +52721,8 @@ try {
     migrationsFolder,
     tailscale: binary === undefined ? undefined : createTailscale({ run: runWith(binary) }),
     artil: findArtilCli(),
+    runSetup,
+    waitForStop,
     out: (line) => console.log(line)
   });
 } catch (cause) {
@@ -52713,5 +52732,5 @@ try {
   process.exitCode = 1;
 }
 
-//# debugId=3707CE11C3FC2DD064756E2164756E21
+//# debugId=874EED01CEF8F5FE64756E2164756E21
 //# sourceMappingURL=main.js.map