Nasıl çalışır

Lambda, bir GenHTTP handler döndüren bir kod parçasıdır. Platform onu derler, yükler ve döndürdüğü şeyi kendi adresinizin altına bağlar. Proje yok, build dosyası yok, using satırı yok. Tüm GenHTTP modülleri zaten içe aktarılmış durumda.

return Content.From(Resource.FromString("hello"));

Bu, eksiksiz bir lambda. /lambda/your-key/ adresinde yayına alındığında her isteğe “hello” kelimesiyle yanıt verir.

Kod parçası bir sınıf değildir, deyimlerden oluşur. Yaptığı son iş, istekleri karşılayabilen bir şey döndürmektir: bir handler ya da onu oluşturan bir builder.

1. 1
   Lambda oluştur düğmesine basın. Herkese açık bir adres ve bir editör anahtarı alırsınız. Anahtar, geri dönmenin tek yolu. Saklayın, çünkü kimse onu sizin için kurtaramaz.
2. 2
   Ardından lambdanın kontrol paneline gelirsiniz. İlk sürüm olarak küçük bir REST servisi hazır bekler. Bu sadece bir başlangıç.
3. 3
   Editör anahtarını bir ajana verin ve ne yapacağını söyleyin. Ajan MCP üzerinden yeni sürümler yazar. Ya da Kod bölümünü açıp kendiniz yazın: Kontrol et hiçbir şey kaydetmeden derler ve derleyicinin ne dediğini dosya ve satırıyla gösterir.
4. 4
   Yayına al düğmesine basın. Artık yayında. Bundan önce hiçbir şeye erişilemez. Yeniden yayına almak da yayında kalma süresini uzatır.

Editör linki bir metin kutusu değil, bir kontrol paneli açar. Buradaki kodun çoğunu ajanlar yazar, bu yüzden ekranda ilk gördüğünüz şey lambdanızın durumudur. Kenar çubuğunda lambdanın kendisi (yayında olup olmadığı, adresi ve daha yeni bir sürüm yayına alınmayı bekliyorsa bir düğme) ve bölümleri yer alır. Adresi değiştirmek ya da lambdayı silmek gibi nadiren yapılan işler, oradaki ⋯ menüsündedir.

Genel bakış

Uygulamanın ne olduğu, yayında olup olmadığı, bugün kaç istek aldığı ve kaçının başarısız olduğu, son değişiklik ve ne kadar yer kaldığı.

Dokümantasyon

Uygulamanın ne olduğu, kimin için ve neden var olduğu ve neden bu şekilde yapıldığı. Ajanlar yazar, her sürümle birlikte saklanır.

Değiştir

Neyin farklı olması gerektiğini yazın, gerisini bu sunucudaki ajan siz izlerken halleder. Değişikliği bir taslakta dener - kendi adresi olan bir kopya - ve çalışınca yayına alır. Taslağı önce kendiniz denemek isterseniz Bitince yayına al seçeneğini kapatın. Ajan yalnızca uygulamanız üzerinde çalışır: Uygulamayla ilgisi olmayan ya da zarar vermeye yönelik bir isteği reddeder ve nedenini söyler.

Taslaklar

Yayına alınmadan önce denenen değişiklikler: her biri kendi adresinde ve kendi test verileriyle çalışır. Açıldığında bir taslağın kendi kodu, test verileri ve logları vardır. Bu bölüm, bir taslak olduğunda görünür.

Dosyalar

Bir sürümün dosyaları: kodu ve statik dosyaları, yani programın kendisi. Kilit ya da dünya simgesi, herkesin onlara erişip erişemeyeceğini gösterir.

Veriler

Lambdanın çalışırken sakladıkları, tüm sürümler için ortak: veritabanı, çalışma alanı ve anahtarlar ve parolalar, her biri kendi sekmesinde. Tablolara ve dosyalara bakın, dosya yükleyin, anahtar ve parola girin ya da bir türü açıp kapatın. Basit görünüm, uygulama bir şey sakladığı anda bu bölümü gösterir.

Sürümler

Her sürümün neyi değiştirdiği, ne istendiği ve bir öncekinden farkı. Buradan yayına alabilir, eski bir sürüme dönebilir ya da herhangi bir sürümden bir taslak başlatabilirsiniz.

Yayın geçmişi

Ne zaman neyin yayında olduğu ve neden yayından kalktığı.

İstatistikler

Son bir saatin ya da günün istekleri, hataları, yanıt süreleri ve en çok istenen yolları.

Loglar

İstekler, lambdanın yazdırdıkları ve ters giden her şeyin stack trace’i, anında.

Kod

Elle yazmak için. Kontrol et derler, Kaydet bir sürüm oluşturur, Yayına al yayına alır. Bir taslakta ise Kaydet onu taslakta tutar ve taslağın adresinde gösterir. Ctrl-S kaydeder, F12 bir tanıma gider.

Testler

Uygulamanın otomatik olarak nasıl test edildiği, bunun için gereken scriptler ve test verileriyle birlikte. Yalnızca tam görünümde.

Her bölüm aynı şekilde çalışır: başlığı, onu açıklayan bir ⓘ simgesi, sağda eylemleri ve birden fazla görünümü varsa altında bir sıra sekme. Kod bölümünde bu sekmeler dosyalardır. Tam görünüm bölümleri gruplar hâlinde toplar: insanların onu nasıl bulduğu, değişikliğin yapıldığı yer, program ile verileri ve nasıl çalıştığı.

Trafik ve log bellekte tutulur. Saklamak için değil, izlemek içindir: sunucu yeniden başlarsa sıfırdan başlarlar. Sürümler ve yayın geçmişi ise kalıcı olarak saklanır.

Bir sürüm, kod ve isteğe bağlı iki nottan oluşur: spesifikasyon, yani kullanıcının ne istediği ve nedeni, mümkünse kendi sözleriyle; ve değişiklik, yani sürümün ne yaptığını anlatan tek bir satır. İkisi de sürüm geçmişinde diff’in yanında görünür. Böylece neden, ne ile yan yana kalır. Hem sizin için, hem de bir şeyi değiştirmeden önce geçmişi okuyan bir sonraki ajan için.

POST /api/v1/lambdas/{editorKey}/versions
{
  "files": [ { "name": "lambda.cs", "code": "..." } ],
  "specification": "İnsanların imza atabileceği bir ziyaretçi defteri; kayıtlar yeniden başlatmada kaybolmamalı",
  "change": "Kayıtları veritabanında tutar, böylece yeniden başlatmada kaybolmazlar"
}

Ajanlar da aynı iki alanı write_code aracına verir. Kod bölümünde kaydederken değişiklik sorulur. İkisi de isteğe bağlıdır. Uzun bir spesifikasyon reddedilmez, 4.000 karakterde kesilir; değişiklik ise 500 karakterde. Bir taslağın da kendi iki notu vardır; birleştirildiği sürüm bunları devralır.

Her sürüm, kendisi hakkında yazılanları programının yanında saklar: dokümantasyonunu (uygulamanın ne olduğu, kimin için ve neden var olduğu, neden bu şekilde yapıldığı) ve testlerini: çalıştığının otomatik olarak nasıl kontrol edileceği, bunun için gereken scriptler ve test verileriyle birlikte. Ajanlar bunları yeni bir lambdayla birlikte yazar ve her değişiklikte günceller. Lambdayı değiştirecek bir sonraki ajan önce bunları okur; böylece uygulamanın ne için olduğunu ve neyin çalışmaya devam etmesi gerektiğini bilir. Kod tek başına bunu söylemez.

.lambda/docs/product.md

uygulamanın ne olduğu, kimin için olduğu, insanların onunla ne yaptığı ve nedeni

.lambda/docs/decisions.md

teknik kararlar ve neden alındıkları

.lambda/tests/README.md

uygulamanın otomatik olarak nasıl test edildiği ve testlerin nasıl çalıştırılacağı

.lambda/tests/…

testlerin kullandığı scriptler ve test verileri

Bunlar, .lambda klasöründe duran ve sürümün diğer dosyaları gibi olan dosyalardır: geçmiş, bir sürümün onlarda neyi değiştirdiğini gösterir; eski bir sürüme dönmek, o sürüm için geçerli olan dokümantasyonu geri getirir; bir taslağın da kendine ait, onunla birlikte yayına giren bir kopyası vardır. Asla derlenmez ve asla sunulmazlar; bir sürümün statik dosyaları için tanınan sınıra dahil edilirler.

Kontrol panelinde Dokümantasyon okunacak sayfaları, Testler ise uygulamanın nasıl test edildiğini ve yanındaki dosyaları gösterir; sürüm, dosyalarında olduğu gibi seçilir. Bir sayfa orada da düzenlenebilir; bu, bir sonraki sürümü kaydeder. Sade görünüm dokümantasyonu Hakkında olarak adlandırır ve yalnızca uygulamanın ne için olduğunu gösterir. Düzeltmek için ajana söyleyin.

Ajanla konuştuğunuz dilde, uygulamayı bir sonraki değiştirecek kişi için yazılırlar; bu bir insan da olabilir, bir ajan da. Kodun bir kopyası değildirler: uygulamanın ne için olduğunu ve nedenini anlatırlar.

Bir sürüm, kaydedildikten sonra bir daha değişmez. Her birini saklamaya değer kılan da bu: herhangi biriyle karşılaştırma yapılabilir, herhangi biri tam olduğu gibi yeniden yayına alınabilir. İnsanların kullandığı bir lambdayı değiştirmek için değişikliği önce bir taslak içinde deneyin.

1. 1
   Sürümler altındaki herhangi bir sürümden başlatın ya da ajanın başlatmasına izin verin. Taslak, o sürümün kodunun, statik dosyalarının, dokümantasyonunun ve testlerinin, bir de lambdanın verilerinin kopyasıdır.
2. 2
   Gerektiği kadar değiştirin: Kod bölümünde ya da ajandan isteyerek. Taslağın önizlemesi kendi adresinde,/features/…/ altında, kendine ait test verileriyle yanıt verir. Lambdanın ziyaretçileri bunların hiçbirini görmez; taslağın yazdığı hiçbir şey lambdanın verilerine ulaşmaz.
3. 3
   Hazır olunca Yayına al düğmesine basın: notlarıyla birlikte bir sonraki sürüm olur ve yayına girer. Taslak ise önizlemesi ve test verileriyle birlikte kaldırılır.

POST /api/v1/lambdas/{editorKey}/features
{ "name": "Skor tablosu" }

PUT  /api/v1/lambdas/{editorKey}/features/{feature}/files?deploy=true
POST /api/v1/lambdas/{editorKey}/features/{feature}/merge
{ "deploy": true }

Aynı anda birden fazla taslak üzerinde çalışılabilir. Yalnızca en yeni sürümle güncel olan bir taslak yayına alınabilir; böylece taslak başladıktan sonra kaydedilen bir sürüm asla geri alınmaz. Önce başka bir taslak yayına alındıysa onun değişikliklerini taslağa taşıyın (ya da ajandan isteyin), sonra taslağı güncel olarak işaretleyin. Hiçbir şey kendiliğinden yayına girmez; bu bilinçli bir tercih. API bir taslağa feature, onu yayına almaya merge der.

Türlerin, onları kullanan kodun altında durması gerekmez. Kod bölümünde dosyaların yanındaki + düğmesine basın. Yeni dosya, kod parçasıyla aynı namespace içinde, onunla birlikte derlenir. Böylece erişmek için hiçbir şeyi içe aktarmanız gerekmez. Uzantısı olmayan bir ad C# dosyası sayılır.

var shelf = new Shelf();

return Inline.Create()
             .Get(() => shelf.All())
             .Post((Book book) => shelf.Add(book));

public sealed class Shelf
{
    private readonly List<Book> _books = [];

    public IEnumerable<Book> All() => _books;

    public Book Add(Book book)
    {
        _books.Add(book);
        return book;
    }
}

public record Book(string Title, string Author);

Sayfa sunmanın iki yolu var. İnsanların yanına yüklediği dosyalar için de bir üçüncüsü.

Tek sayfa, kodun içinde

Küçük şeyler için yeterli. Sayfa doğrudan kodun içinde yer alır.

var page = Resource.FromString("""
                              <!doctype html>
                              <title>Mine</title>
                              <h1>It works</h1>
                              """)
                   .Type(new ContentType("text/html; charset=utf-8"));

return Content.From(page);

Gerçek dosyalarla bir klasör

Stil dosyası ve script içeren her şey için doğru seçim. Dosyalar tıpkı bir C# dosyası gibi eklenir ve tam yazıldığı gibi sunulur. Derlenmezler.

return Layout.Create()
             .Add("api", api)
             .Add(Assets.App("site"));

Yüklenen dosyalar, verilerden

İnsanların yüklediği ya da lambdanın oluşturduğu şeyler (görseller, belgeler) için; uygulamanın yanında sunulurlar. Uygulamanın kendi sayfaları için değil: onların yeri bir dosya klasörüdür, orada onlara ihtiyaç duyan kodla birlikte sürümlenirler.

return Layout.Create()
             .Add("api", api)
             .Add("uploads", Workspace.Files("uploads"))
             .Add(Assets.App("site"));

Bunların ikincisi, baştan sona. Her demo, sayfasını bu şekilde web adlı bir klasörden sunar. Bir örnek görmek için demo-crud demosunu açın. Demolar salt okunurdur; editör anahtarları adlarıyla aynıdır.

1. 1
   Kod bölümünde dosyaların yanındaki + düğmesine basın ve site/index.html yazın. Adında eğik çizgi olan bir dosya bir klasöre girer. Uzantısı olan bir ad da uzantısının söylediği türde dosya sayılır.
2. 2
   site/app.css ve site/app.js dosyalarını da aynı şekilde ekleyin. Sayfanız onlara href="app.css" örneğindeki gibi adlarıyla başvurur. Çünkü klasör adresin bir parçası değil, sunulan içeriğin köküdür.
3. 3
   Görsel ya da font gibi metin olmayan dosyalar için site klasöründeki bir dosyayı açın ve dosyaların yanındaki yükleme düğmesine basın. Dosya aynı klasöre gider. PNG bir metin editöründe yazılamaz, o yüzden yolu bu.
4. 4
   lambda.cs dosyasında klasörü sunun:

   return Layout.Create().Add(Assets.App("site"));

5. 5
   Yayına al düğmesine basın. site/index.html dosyası / adresinde, site/app.css dosyası /app.css adresinde yanıt verir. Hiçbir dosyayla eşleşmeyen her adreste sayfanın kendisi döner. Böylece kendi yönlendirmesini yapan bir frontend, biri bir deep link üzerinde sayfayı yenilediğinde de çalışır.
6. 6
   Yanına bir API ekleyin, sayfanın konuşacağı bir şey olsun:

   var api = Inline.Create().Get("notes", () => notes);
   
   return Layout.Create()
                .Add("api", api)
                .Add(Assets.App("site"));

Bir lambda dosyaları iki yerde tutar ve editör onları ayrı gösterir: Dosyalar bir sürümün dosyalarını (programı), Veriler ise çalışma alanını (programın sakladıklarını) tutar. Fark, kime ait olduklarında yatar. Bir sürümün dosyaları o sürüme aittir; veriler ise lambdaya aittir ve her sürüm onları paylaşır.

İkisi tek bir yer olamaz. Olsaydı, her yayına alma ya lambdanızın o zamandan beri yazdığı her şeyi silerdi ya da yayına aldığınız dosyalardan hiçbir şey kaldırılamazdı. Skor tablosu tutan bir oyun ikincisini ister, sunduğu sayfa ise birincisini. Bu yüzden sayfa sürüme, skor tablosu da verilere girer.

Kayıtlar (girdiler, hesaplar, siparişler, oylar) veritabanına aittir: lambdanın kendine ait, Veriler altında açılan bir SQLite veritabanı. Kod Database.GetConnection() ile bir bağlantı açar ve tabloları eşleyen kendi bağlamıyla veritabanını Entity Framework Core üzerinden okuyup yazar:

// migrations/V1__Create_notes.sql:
//   CREATE TABLE notes (id INTEGER PRIMARY KEY, text TEXT NOT NULL);

using (var connection = Database.GetConnection())
{
    new Evolve(connection) { Locations = [Assets.Root + "migrations"] }.Migrate();
}

return Inline.Create()
             .Get("notes", () =>
             {
                 using var db = new Notes(Database.GetConnection());

                 return db.Entries.OrderBy(n => n.Id).Select(n => n.Text).ToList();
             })
             .Post("notes", (NoteInput input) =>
             {
                 using var db = new Notes(Database.GetConnection());

                 db.Entries.Add(new Note { Text = input.Text });

                 return db.SaveChanges();
             });

record NoteInput(string Text);

class Note
{
    public long Id { get; set; }

    public string Text { get; set; }
}

// maps the table the migration made, on the connection it is handed
class Notes(SqliteConnection connection) : DbContext
{
    public DbSet<Note> Entries => Set<Note>();

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlite(connection, contextOwnsConnection: true);

    protected override void OnModelCreating(ModelBuilder model)
        => model.Entity<Note>().ToTable("notes");
}

Tablolarını migration’lar oluşturur: sürümle birlikte migrations/ içinde gelen ve lambda başlarken Evolve tarafından sırayla uygulanan SQL dosyaları. Her biri yalnızca bir kez uygulanır, yani yeni bir sürüm yalnızca yeni olanı çalıştırır. Uygulanmış bir migration’ı asla değiştirmeyin; bir tablodaki değişiklik bir sonraki dosyadır.

Tüm veriler gibi veritabanı da tüm sürümler için ortaktır; yayına alma ve eski bir sürüme dönme ona dokunmaz, bir taslak ise onun bir kopyası üzerinde çalışır. Veriler altında tablolarını ve içlerindekileri görürsünüz; basit görünüm bunlara kayıt der. .NET projesi olarak indir onu düz bir SQLite dosyası olarak birlikte getirir.

Bağlamı ihtiyaç duyduğunuz yerde oluşturun, işiniz bitince serbest bırakın ve senkron kullanın: ToListAsync ve SaveChangesAsync değil, ToList ve SaveChanges. Tabloları migration’lar oluşturur, asla Entity Framework değil. demo-crud demosu bunların hepsini yapar.

Workspace, lambdanızın okuyup yazabildiği özel bir klasördür ve dosyaların yeridir: birinin yüklediği görseller, lambdanın oluşturduğu bir belge, okuduğu bir model. Kayıtlar veritabanına aittir; bir dosya hakkında bilinenler (kimin ve ne zaman yüklediği) de bir kayıttır.

// uploads go into a folder of their own, served as they are
Workspace.CreateFolder("photos");

return Layout.Create()
             .Add("photos", Workspace.Files("photos"))
             .Add("upload", Inline.Create().Post(async (Stream body) =>
             {
                 using var content = new MemoryStream();

                 await body.CopyToAsync(content);

                 Workspace.WriteBytes($"photos/{Guid.NewGuid():N}.jpg", content.ToArray());
             }));

Ayrıca ReadBytes, WriteBytes, Delete, List, CreateFolder ve içeriği sunmak için Tree/Files/App da var. Dosya sisteminin geri kalanına erişilemez.

Bir API anahtarı, parola veya token koda değil gizli değerlere aittir; kodda her sürüm, her indirme ve geçmişi okuyan herkes ona sahip olurdu. Kod bir gizli değeri adıyla okur:

var weather = new System.Net.Http.HttpClient();

weather.DefaultRequestHeaders.Add("X-Api-Key", Secret.Read("WEATHER_API_KEY"));

return Inline.Create()
             .Get("today", async () => await weather.GetStringAsync("https://weather.example/today"));

Gizli değerleri Veriler altında açın ve değeri orada ayarlayın. Kaydedildikten sonra bir daha gösterilmez – ne size ne de bir ajana; yalnızca değiştirebilirsiniz. Liste, kodun okuduğu ama henüz değeri olmayan adları gösterir, genel bakış da bunları ister. Secret.Exists bir değerin ayarlı olup olmadığını söyler; onsuz da çalışan kod için. Tüm veriler gibi gizli değerler de tüm sürümler için ortaktır ve bir taslak bir kopya üzerinde çalışır.

Veritabanında bulunmayan bir anahtarla şifrelenmiş olarak saklanırlar. İndirilen bir projede Secret.Read("NAME") NAME ortam değişkenini okur – değerlerin kendisi burada kalır.

Destekleniyor, hem de sonradan akla gelmiş bir özellik olarak değil. demo-game demosu oyuncuları eşleştirir ve her oyunu sunucuda yürütür. En basit hâli üç callback’ten oluşur:

var room = new ConcurrentDictionary<IReactiveConnection, string>();

var socket = Websocket.Functional()
                      .OnOpen(c => { room[c] = "someone"; return ValueTask.CompletedTask; })
                      .OnMessage(async (c, text) =>
                      {
                          foreach (var other in room.Keys)
                          {
                              await other.WritePayloadAsync(text);
                          }
                      })
                      .OnClose((c, _) => { room.TryRemove(c, out _); return ValueTask.CompletedTask; });

return Layout.Create().Add("chat", socket);

Sayfa yalnızca dinliyorsa (bir sayaç, bir akış, bir skor tablosu) sunucu tarafından gönderilen olaylar daha basittir: sunucunun yazmaya devam ettiği ve tarayıcının kendiliğinden yeniden bağlandığı tek bir uzun yanıt. demo-live demosu her oyu bu yolla o sırada izleyen herkese gönderir. Hangisini seçerseniz seçin, değişeni sunucu iletir. Birkaç saniyede bir yeniden soran bir sayfa, bir şey değişmiş olsun olmasın her seferinde bir istek gönderir ve yine de geç kalır.

Herkesin takıldığı bir nokta var: tarayıcı, websocket el sıkışmasında header ekleyemez. Handler’ın ihtiyaç duyduğu bilgiyi sorgu parametrelerinde gönderin; handler onu connection.Request.Header.Query üzerinden okur. Ya da gizli bilgileri ilk mesaj olarak gönderin.

Kodunuz ortak bir sunucuda çalışır. Bu yüzden C# dilinin bazı kısımları derlenmeden önce reddedilir: süreç başlatmak, kendi soketlerinizi açmak, assembly yüklemek, çalışma alanınızın dışında dosya sistemine erişmek ve bunları aşmak için reflection kullanmak. Bir task’ı await yerine .Result veya .Wait() ile beklemek de reddedilir: istekler çekirdek başına tek bir thread üzerinde çalışır ve task, onu bekleyen thread’in ta kendisinde tamamlanmak zorunda kalırdı.

Geri kalan her şey mevcut, GenHTTP modül API’sinin tamamı dahil. Bir şey reddedilirse sadece başarısız olduğu değil, hangi satırda ve neden reddedildiği de söylenir.

Editördeki .NET projesi olarak indir ile lambdanın tamamını alırsınız: açabileceğiniz, dotnet run ile çalıştırabileceğiniz ve saklayabileceğiniz bir solution. Yalnızca GenHTTP paketine ihtiyaç duyar ve container olarak derleyip çalıştırmanız için bir Dockerfile ile gelir.

Kod parçanız Project.cs olur, Program.cs de döndürdüğü şeyi sunar. Diğer dosyalarınız tam yazdığınız gibi gelir. Workspace ve Assets programın yanında, ayrı bir Platform klasöründe iki klasör olur ve aynı metotlarla çalışır. Yani kodunuzda hiçbir şeyi değiştirmeniz gerekmez. Secret orada aynı adlı ortam değişkenlerini okur; değerler burada kalır. Dokümantasyon ve testler de docs ve tests klasörlerinde gelir. Database ise database/database.db dosyasını açar; indirilen proje bu dosyayı uygulamanızın tuttuğu kayıtlarla birlikte getirir.

Burada bir şey yapmadan önce bilmekte fayda var: yazdığınız kod sizindir ve eksiksiz olarak sizinle gelir. Onu bu makinede çalıştırmak, onu bu makineye bağlamaz.

Yaptığınız şey başka birinin işine yarayabilecekse kodunu yayımlayın: kontrol panelinde Açık kaynak bölümünü açın, bir lisans seçin (başka bir lisans istemiyorsanız MIT) ve düğmeyi açın. Kodu, açık kaynak uygulamalar arasında kendi sayfasını alır. Orada herkes onu okuyabilir, ona yıldız verebilir ve herhangi bir sürümünü, .NET projesi olarak indir ile aldığınız projenin aynısı olarak, yanında lisansıyla birlikte indirebilir.

Her sürüm yayımlanır, öncekiler de; her biri dokümantasyonu, testleri ve yaptığı değişiklikle birlikte. Uygulamanın sakladıkları (kayıtları, kaydettiği dosyalar, anahtarlarının ve parolalarının değerleri) asla yayımlanmaz; kendi sözlerinizle ne istediğiniz ve uygulamayı kimlerin kullandığı da. Kapattığınızda sayfa kaldırılır; yıldızları ise yeniden yayımladığınızda geri gelmek üzere saklanır.

Koddaki her şey herkese açık hâle gelir, önceki sürümler de dahil. Bir anahtarın ya da parolanın yeri, Veriler altındaki anahtarlar ve parolalardır; yayımlansın ya da yayımlanmasın, asla kod değildir.

/mcp adresinde bir MCP endpoint’i var. Bir ajanı buraya bağlayın, editörün yaptığı her şeyi yapabilir: kılavuzu okur, bir demoyu baştan sona inceler, dosya yazar, derler ve yayına alır. Altta aynı API çalışır.

Ajan çalışırken nedenini de söyler (write_code aracı spesifikasyonu ve değişikliği alır) ve yayına aldığı şeye bakabilir: read_logs aracı lambdanın son isteklerini, yazdırdıklarını ve fırlattığı her hatanın stack trace’ini döndürür. Ajan, kodunun çalıştığını varsaymak yerine böyle öğrenir. Siz de aynı şeyi kontrol panelinde izlersiniz. Ajan çalışırken dokümantasyonu ve testleri de yazar, bir şeyi değiştirmeden önce onları okur ve bir taslağı yayına almadan önce testleri taslağın adresi üzerinde çalıştırır. Bulunması istenen bir sayfaya başlık, açıklama, simge ve linki paylaşıldığında görünen bir önizleme ekler. Oluşturduğu sayfaların altına, GenHTTP Lambda ile yapıldıklarını belirten küçük bir satır ekler; istemezseniz ajana söyleyin, satırı kaldırır.

Daha fazlası →